# encoding: utf-8
        
      
        

          
          
          # Encoding.default_internal = 'UTF-8'
        
      
        

          
          
          
        
      
        

          
          
          # = CodeRay Library
        
      
        

          
          
          #
        
      
        

          
          
          # CodeRay is a Ruby library for syntax highlighting.
        
      
        

          
          
          #
        
      
        

          
          
          # I try to make CodeRay easy to use and intuitive, but at the same time fully
        
      
        

          
          
          # featured, complete, fast and efficient.
        
      
        

          
          
          # 
        
      
        

          
          
          # See README.
        
      
        

          
          
          # 
        
      
        

          
          
          # It consists mainly of
        
      
        

          
          
          # * the main engine: CodeRay (Scanners::Scanner, Tokens, Encoders::Encoder)
        
      
        

          
          
          # * the plugin system: PluginHost, Plugin
        
      
        

          
          
          # * the scanners in CodeRay::Scanners
        
      
        

          
          
          # * the encoders in CodeRay::Encoders
        
      
        

          
          
          # * the styles in CodeRay::Styles
        
      
        

          
          
          # 
        
      
        

          
          
          # Here's a fancy graphic to light up this gray docu:
        
      
        

          
          
          # 
        
      
        

          
          
          # http://cycnus.de/raindark/coderay/scheme.png
        
      
        

          
          
          # 
        
      
        

          
          
          # == Documentation
        
      
        

          
          
          #
        
      
        

          
          
          # See CodeRay, Encoders, Scanners, Tokens.
        
      
        

          
          
          #
        
      
        

          
          
          # == Usage
        
      
        

          
          
          #
        
      
        

          
          
          # Remember you need RubyGems to use CodeRay, unless you have it in your load
        
      
        

          
          
          # path. Run Ruby with -rubygems option if required.
        
      
        

          
          
          #
        
      
        

          
          
          # === Highlight Ruby code in a string as html
        
      
        

          
          
          # 
        
      
        

          
          
          #   require 'coderay'
        
      
        

          
          
          #   print CodeRay.scan('puts "Hello, world!"', :ruby).html
        
      
        

          
          
          #
        
      
        

          
          
          #   # prints something like this:
        
      
        

          
          
          #   puts <span class="s">&quot;Hello, world!&quot;</span>
        
      
        

          
          
          # 
        
      
        

          
          
          # 
        
      
        

          
          
          # === Highlight C code from a file in a html div
        
      
        

          
          
          # 
        
      
        

          
          
          #   require 'coderay'
        
      
        

          
          
          #   print CodeRay.scan(File.read('ruby.h'), :c).div
        
      
        

          
          
          #   print CodeRay.scan_file('ruby.h').html.div
        
      
        

          
          
          # 
        
      
        

          
          
          # You can include this div in your page. The used CSS styles can be printed with
        
      
        

          
          
          # 
        
      
        

          
          
          #   % coderay_stylesheet
        
      
        

          
          
          # 
        
      
        

          
          
          # === Highlight without typing too much
        
      
        

          
          
          # 
        
      
        

          
          
          # If you are one of the hasty (or lazy, or extremely curious) people, just run this file:
        
      
        

          
          
          # 
        
      
        

          
          
          #   % ruby -rubygems /path/to/coderay/coderay.rb > example.html
        
      
        

          
          
          # 
        
      
        

          
          
          # and look at the file it created in your browser.
        
      
        

          
          
          # 
        
      
        

          
          
          # = CodeRay Module
        
      
        

          
          
          #
        
      
        

          
          
          # The CodeRay module provides convenience methods for the engine.
        
      
        

          
          
          #
        
      
        

          
          
          # * The +lang+ and +format+ arguments select Scanner and Encoder to use. These are
        
      
        

          
          
          #   simply lower-case symbols, like <tt>:python</tt> or <tt>:html</tt>.
        
      
        

          
          
          # * All methods take an optional hash as last parameter, +options+, that is send to
        
      
        

          
          
          #   the Encoder / Scanner.
        
      
        

          
          
          # * Input and language are always sorted in this order: +code+, +lang+.
        
      
        

          
          
          #   (This is in alphabetical order, if you need a mnemonic ;)
        
      
        

          
          
          # 
        
      
        

          
          
          # You should be able to highlight everything you want just using these methods;
        
      
        

          
          
          # so there is no need to dive into CodeRay's deep class hierarchy.
        
      
        

          
          
          #
        
      
        

          
          
          # The examples in the demo directory demonstrate common cases using this interface.
        
      
        

          
          
          #  
        
      
        

          
          
          # = Basic Access Ways
        
      
        

          
          
          #
        
      
        

          
          
          # Read this to get a general view what CodeRay provides.
        
      
        

          
          
          # 
        
      
        

          
          
          # == Scanning
        
      
        

          
          
          # 
        
      
        

          
          
          # Scanning means analysing an input string, splitting it up into Tokens.
        
      
        

          
          
          # Each Token knows about what type it is: string, comment, class name, etc.
        
      
        

          
          
          #
        
      
        

          
          
          # Each +lang+ (language) has its own Scanner; for example, <tt>:ruby</tt> code is
        
      
        

          
          
          # handled by CodeRay::Scanners::Ruby.
        
      
        

          
          
          # 
        
      
        

          
          
          # CodeRay.scan:: Scan a string in a given language into Tokens.
        
      
        

          
          
          #                This is the most common method to use.
        
      
        

          
          
          # CodeRay.scan_file:: Scan a file and guess the language using FileType.
        
      
        

          
          
          # 
        
      
        

          
          
          # The Tokens object you get from these methods can encode itself; see Tokens.
        
      
        

          
          
          # 
        
      
        

          
          
          # == Encoding
        
      
        

          
          
          #
        
      
        

          
          
          # Encoding means compiling Tokens into an output. This can be colored HTML or
        
      
        

          
          
          # LaTeX, a textual statistic or just the number of non-whitespace tokens.
        
      
        

          
          
          # 
        
      
        

          
          
          # Each Encoder provides output in a specific +format+, so you select Encoders via
        
      
        

          
          
          # formats like <tt>:html</tt> or <tt>:statistic</tt>.
        
      
        

          
          
          # 
        
      
        

          
          
          # CodeRay.encode:: Scan and encode a string in a given language.
        
      
        

          
          
          # CodeRay.encode_tokens:: Encode the given tokens.
        
      
        

          
          
          # CodeRay.encode_file:: Scan a file, guess the language using FileType and encode it.
        
      
        

          
          
          #
        
      
        

          
          
          # == All-in-One Encoding
        
      
        

          
          
          #
        
      
        

          
          
          # CodeRay.encode:: Highlight a string with a given input and output format.
        
      
        

          
          
          #
        
      
        

          
          
          # == Instanciating
        
      
        

          
          
          #
        
      
        

          
          
          # You can use an Encoder instance to highlight multiple inputs. This way, the setup
        
      
        

          
          
          # for this Encoder must only be done once.
        
      
        

          
          
          #
        
      
        

          
          
          # CodeRay.encoder:: Create an Encoder instance with format and options.
        
      
        

          
          
          # CodeRay.scanner:: Create an Scanner instance for lang, with '' as default code.
        
      
        

          
          
          #
        
      
        

          
          
          # To make use of CodeRay.scanner, use CodeRay::Scanner::code=.
        
      
        

          
          
          #
        
      
        

          
          
          # The scanning methods provide more flexibility; we recommend to use these.
        
      
        

          
          
          # 
        
      
        

          
          
          # == Reusing Scanners and Encoders
        
      
        

          
          
          # 
        
      
        

          
          
          # If you want to re-use scanners and encoders (because that is faster), see
        
      
        

          
          
          # CodeRay::Duo for the most convenient (and recommended) interface.
        
      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          1
          
            $CODERAY_DEBUG ||= false
        
      
        

          
          
            
        
      
        

          1
          
            CODERAY_PATH = File.expand_path('../coderay', __FILE__)
        
      
        

          
          
            
        
      
        

          
          
            # Assuming the path is a subpath of lib/coderay/
        
      
        

          1
          
            def self.coderay_path *path
        
      
        

          13
          
              File.join CODERAY_PATH, *path
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          1
          
            require 'coderay/version'
        
      
        

          
          
            
        
      
        

          
          
            # helpers
        
      
        

          1
          
            autoload :FileType,    coderay_path('helpers', 'file_type')
        
      
        

          
          
            
        
      
        

          
          
            # Tokens
        
      
        

          1
          
            autoload :Tokens,      coderay_path('tokens')
        
      
        

          1
          
            autoload :TokensProxy, coderay_path('tokens_proxy')
        
      
        

          1
          
            autoload :TokenKinds,  coderay_path('token_kinds')
        
      
        

          
          
            
        
      
        

          
          
            # Plugin system
        
      
        

          1
          
            autoload :PluginHost,  coderay_path('helpers', 'plugin')
        
      
        

          1
          
            autoload :Plugin,      coderay_path('helpers', 'plugin')
        
      
        

          
          
            
        
      
        

          
          
            # Plugins
        
      
        

          1
          
            autoload :Scanners,    coderay_path('scanner')
        
      
        

          1
          
            autoload :Encoders,    coderay_path('encoder')
        
      
        

          1
          
            autoload :Styles,      coderay_path('style')
        
      
        

          
          
            
        
      
        

          
          
            # convenience access and reusable Encoder/Scanner pair
        
      
        

          1
          
            autoload :Duo,         coderay_path('duo')
        
      
        

          
          
            
        
      
        

          1
          
            class << self
        
      
        

          
          
              
        
      
        

          
          
              # Scans the given +code+ (a String) with the Scanner for +lang+.
        
      
        

          
          
              #
        
      
        

          
          
              # This is a simple way to use CodeRay. Example:
        
      
        

          
          
              #  require 'coderay'
        
      
        

          
          
              #  page = CodeRay.scan("puts 'Hello, world!'", :ruby).html
        
      
        

          
          
              #
        
      
        

          
          
              # See also demo/demo_simple.
        
      
        

          1
          
              def scan code, lang, options = {}, &block
        
      
        

          94
          
                TokensProxy.new code, lang, options, block
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Scans +filename+ (a path to a code file) with the Scanner for +lang+.
        
      
        

          
          
              #
        
      
        

          
          
              # If +lang+ is :auto or omitted, the CodeRay::FileType module is used to
        
      
        

          
          
              # determine it. If it cannot find out what type it is, it uses
        
      
        

          
          
              # CodeRay::Scanners::Text.
        
      
        

          
          
              #
        
      
        

          
          
              # Calls CodeRay.scan.
        
      
        

          
          
              #
        
      
        

          
          
              # Example:
        
      
        

          
          
              #  require 'coderay'
        
      
        

          
          
              #  page = CodeRay.scan_file('some_c_code.c').html
        
      
        

          1
          
              def scan_file filename, lang = :auto, options = {}, &block
        
      
        

          
          
                lang = FileType.fetch filename, :text, true if lang == :auto
        
      
        

          
          
                code = File.read filename
        
      
        

          
          
                scan code, lang, options, &block
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Encode a string.
        
      
        

          
          
              #
        
      
        

          
          
              # This scans +code+ with the the Scanner for +lang+ and then
        
      
        

          
          
              # encodes it with the Encoder for +format+.
        
      
        

          
          
              # +options+ will be passed to the Encoder.
        
      
        

          
          
              #
        
      
        

          
          
              # See CodeRay::Encoder.encode.
        
      
        

          1
          
              def encode code, lang, format, options = {}
        
      
        

          81
          
                encoder(format, options).encode code, lang, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Encode pre-scanned Tokens.
        
      
        

          
          
              # Use this together with CodeRay.scan:
        
      
        

          
          
              #
        
      
        

          
          
              #  require 'coderay'
        
      
        

          
          
              #  
        
      
        

          
          
              #  # Highlight a short Ruby code example in a HTML span
        
      
        

          
          
              #  tokens = CodeRay.scan '1 + 2', :ruby
        
      
        

          
          
              #  puts CodeRay.encode_tokens(tokens, :span)
        
      
        

          
          
              #
        
      
        

          1
          
              def encode_tokens tokens, format, options = {}
        
      
        

          
          
                encoder(format, options).encode_tokens tokens, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Encodes +filename+ (a path to a code file) with the Scanner for +lang+.
        
      
        

          
          
              #
        
      
        

          
          
              # See CodeRay.scan_file.
        
      
        

          
          
              # Notice that the second argument is the output +format+, not the input language.
        
      
        

          
          
              #
        
      
        

          
          
              # Example:
        
      
        

          
          
              #  require 'coderay'
        
      
        

          
          
              #  page = CodeRay.encode_file 'some_c_code.c', :html
        
      
        

          1
          
              def encode_file filename, format, options = {}
        
      
        

          
          
                tokens = scan_file filename, :auto, get_scanner_options(options)
        
      
        

          
          
                encode_tokens tokens, format, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Highlight a string into a HTML <div>.
        
      
        

          
          
              #
        
      
        

          
          
              # CSS styles use classes, so you have to include a stylesheet
        
      
        

          
          
              # in your output.
        
      
        

          
          
              #
        
      
        

          
          
              # See encode.
        
      
        

          1
          
              def highlight code, lang, options = { :css => :class }, format = :div
        
      
        

          
          
                encode code, lang, format, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Highlight a file into a HTML <div>.
        
      
        

          
          
              #
        
      
        

          
          
              # CSS styles use classes, so you have to include a stylesheet
        
      
        

          
          
              # in your output.
        
      
        

          
          
              #
        
      
        

          
          
              # See encode.
        
      
        

          1
          
              def highlight_file filename, options = { :css => :class }, format = :div
        
      
        

          
          
                encode_file filename, format, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Finds the Encoder class for +format+ and creates an instance, passing
        
      
        

          
          
              # +options+ to it.
        
      
        

          
          
              #
        
      
        

          
          
              # Example:
        
      
        

          
          
              #  require 'coderay'
        
      
        

          
          
              #  
        
      
        

          
          
              #  stats = CodeRay.encoder(:statistic)
        
      
        

          
          
              #  stats.encode("puts 17 + 4\n", :ruby)
        
      
        

          
          
              #  
        
      
        

          
          
              #  puts '%d out of %d tokens have the kind :integer.' % [
        
      
        

          
          
              #    stats.type_stats[:integer].count,
        
      
        

          
          
              #    stats.real_token_count
        
      
        

          
          
              #  ]
        
      
        

          
          
              #  #-> 2 out of 4 tokens have the kind :integer.
        
      
        

          1
          
              def encoder format, options = {}
        
      
        

          81
          
                Encoders[format].new options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Finds the Scanner class for +lang+ and creates an instance, passing
        
      
        

          
          
              # +options+ to it.
        
      
        

          
          
              #
        
      
        

          
          
              # See Scanner.new.
        
      
        

          1
          
              def scanner lang, options = {}, &block
        
      
        

          13
          
                Scanners[lang].new '', options, &block
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Extract the options for the scanner from the +options+ hash.
        
      
        

          
          
              #
        
      
        

          
          
              # Returns an empty Hash if <tt>:scanner_options</tt> is not set.
        
      
        

          
          
              #
        
      
        

          
          
              # This is used if a method like CodeRay.encode has to provide options
        
      
        

          
          
              # for Encoder _and_ scanner.
        
      
        

          1
          
              def get_scanner_options options
        
      
        

          81
          
                options.fetch :scanner_options, {}
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          
          
            # This module holds the Encoder class and its subclasses.
        
      
        

          
          
            # For example, the HTML encoder is named CodeRay::Encoders::HTML
        
      
        

          
          
            # can be found in coderay/encoders/html.
        
      
        

          
          
            #
        
      
        

          
          
            # Encoders also provides methods and constants for the register
        
      
        

          
          
            # mechanism and the [] method that returns the Encoder class
        
      
        

          
          
            # belonging to the given format.
        
      
        

          1
          
            module Encoders
        
      
        

          
          
              
        
      
        

          1
          
              extend PluginHost
        
      
        

          1
          
              plugin_path File.dirname(__FILE__), 'encoders'
        
      
        

          
          
              
        
      
        

          
          
              # = Encoder
        
      
        

          
          
              #
        
      
        

          
          
              # The Encoder base class. Together with Scanner and
        
      
        

          
          
              # Tokens, it forms the highlighting triad.
        
      
        

          
          
              #
        
      
        

          
          
              # Encoder instances take a Tokens object and do something with it.
        
      
        

          
          
              #
        
      
        

          
          
              # The most common Encoder is surely the HTML encoder
        
      
        

          
          
              # (CodeRay::Encoders::HTML). It highlights the code in a colorful
        
      
        

          
          
              # html page.
        
      
        

          
          
              # If you want the highlighted code in a div or a span instead,
        
      
        

          
          
              # use its subclasses Div and Span.
        
      
        

          1
          
              class Encoder
        
      
        

          1
          
                extend Plugin
        
      
        

          1
          
                plugin_host Encoders
        
      
        

          
          
                
        
      
        

          1
          
                class << self
        
      
        

          
          
                  
        
      
        

          
          
                  # If FILE_EXTENSION isn't defined, this method returns the
        
      
        

          
          
                  # downcase class name instead.
        
      
        

          1
          
                  def const_missing sym
        
      
        

          
          
                    if sym == :FILE_EXTENSION
        
      
        

          
          
                      (defined?(@plugin_id) && @plugin_id || name[/\w+$/].downcase).to_s
        
      
        

          
          
                    else
        
      
        

          
          
                      super
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                  # The default file extension for output file of this encoder class.
        
      
        

          1
          
                  def file_extension
        
      
        

          
          
                    self::FILE_EXTENSION
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Subclasses are to store their default options in this constant.
        
      
        

          1
          
                DEFAULT_OPTIONS = { }
        
      
        

          
          
                
        
      
        

          
          
                # The options you gave the Encoder at creating.
        
      
        

          1
          
                attr_accessor :options, :scanner
        
      
        

          
          
                
        
      
        

          
          
                # Creates a new Encoder.
        
      
        

          
          
                # +options+ is saved and used for all encode operations, as long
        
      
        

          
          
                # as you don't overwrite it there by passing additional options.
        
      
        

          
          
                #
        
      
        

          
          
                # Encoder objects provide three encode methods:
        
      
        

          
          
                # - encode simply takes a +code+ string and a +lang+
        
      
        

          
          
                # - encode_tokens expects a +tokens+ object instead
        
      
        

          
          
                #
        
      
        

          
          
                # Each method has an optional +options+ parameter. These are
        
      
        

          
          
                # added to the options you passed at creation.
        
      
        

          1
          
                def initialize options = {}
        
      
        

          81
          
                  @options = self.class::DEFAULT_OPTIONS.merge options
        
      
        

          81
          
                  @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN = false
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Encode a Tokens object.
        
      
        

          1
          
                def encode_tokens tokens, options = {}
        
      
        

          
          
                  options = @options.merge options
        
      
        

          
          
                  @scanner = tokens.scanner if tokens.respond_to? :scanner
        
      
        

          
          
                  setup options
        
      
        

          
          
                  compile tokens, options
        
      
        

          
          
                  finish options
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Encode the given +code+ using the Scanner for +lang+.
        
      
        

          1
          
                def encode code, lang, options = {}
        
      
        

          81
          
                  options = @options.merge options
        
      
        

          81
          
                  @scanner = Scanners[lang].new code, CodeRay.get_scanner_options(options).update(:tokens => self)
        
      
        

          81
          
                  setup options
        
      
        

          81
          
                  @scanner.tokenize
        
      
        

          81
          
                  finish options
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # You can use highlight instead of encode, if that seems
        
      
        

          
          
                # more clear to you.
        
      
        

          1
          
                alias highlight encode
        
      
        

          
          
                
        
      
        

          
          
                # The default file extension for this encoder.
        
      
        

          1
          
                def file_extension
        
      
        

          
          
                  self.class.file_extension
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def << token
        
      
        

          
          
                  unless @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN
        
      
        

          
          
                    warn 'Using old Tokens#<< interface.'
        
      
        

          
          
                    @@CODERAY_TOKEN_INTERFACE_DEPRECATION_WARNING_GIVEN = true
        
      
        

          
          
                  end
        
      
        

          
          
                  self.token(*token)
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Called with +content+ and +kind+ of the currently scanned token.
        
      
        

          
          
                # For simple scanners, it's enougth to implement this method.
        
      
        

          
          
                #
        
      
        

          
          
                # By default, it calls text_token, begin_group, end_group, begin_line,
        
      
        

          
          
                # or end_line, depending on the +content+.
        
      
        

          1
          
                def token content, kind
        
      
        

          
          
                  case content
        
      
        

          
          
                  when String
        
      
        

          
          
                    text_token content, kind
        
      
        

          
          
                  when :begin_group
        
      
        

          
          
                    begin_group kind
        
      
        

          
          
                  when :end_group
        
      
        

          
          
                    end_group kind
        
      
        

          
          
                  when :begin_line
        
      
        

          
          
                    begin_line kind
        
      
        

          
          
                  when :end_line
        
      
        

          
          
                    end_line kind
        
      
        

          
          
                  else
        
      
        

          
          
                    raise ArgumentError, 'Unknown token content type: %p, kind = %p' % [content, kind]
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Called for each text token ([text, kind]), where text is a String.
        
      
        

          1
          
                def text_token text, kind
        
      
        

          
          
                  @out << text
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Starts a token group with the given +kind+.
        
      
        

          1
          
                def begin_group kind
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Ends a token group with the given +kind+.
        
      
        

          1
          
                def end_group kind
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Starts a new line token group with the given +kind+.
        
      
        

          1
          
                def begin_line kind
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Ends a new line token group with the given +kind+.
        
      
        

          1
          
                def end_line kind
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
              protected
        
      
        

          
          
                
        
      
        

          
          
                # Called with merged options before encoding starts.
        
      
        

          
          
                # Sets @out to an empty string.
        
      
        

          
          
                #
        
      
        

          
          
                # See the HTML Encoder for an example of option caching.
        
      
        

          1
          
                def setup options
        
      
        

          81
          
                  @out = get_output(options)
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def get_output options
        
      
        

          81
          
                  options[:out] || ''
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Append data.to_s to the output. Returns the argument.
        
      
        

          1
          
                def output data
        
      
        

          
          
                  @out << data.to_s
        
      
        

          
          
                  data
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Called with merged options after encoding starts.
        
      
        

          
          
                # The return value is the result of encoding, typically @out.
        
      
        

          1
          
                def finish options
        
      
        

          81
          
                  @out
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Do the encoding.
        
      
        

          
          
                #
        
      
        

          
          
                # The already created +tokens+ object must be used; it must be a
        
      
        

          
          
                # Tokens object.
        
      
        

          1
          
                def compile tokens, options = {}
        
      
        

          
          
                  content = nil
        
      
        

          
          
                  for item in tokens
        
      
        

          
          
                    if item.is_a? Array
        
      
        

          
          
                      raise ArgumentError, 'Two-element array tokens are no longer supported.'
        
      
        

          
          
                    end
        
      
        

          
          
                    if content
        
      
        

          
          
                      token content, item
        
      
        

          
          
                      content = nil
        
      
        

          
          
                    else
        
      
        

          
          
                      content = item
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                  raise 'odd number list for Tokens' if content
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                alias tokens compile
        
      
        

          1
          
                public :tokens
        
      
        

          
          
                
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          1
          
          module Encoders
        
      
        

          
          
            
        
      
        

          1
          
            map \
        
      
        

          
          
              :loc             => :lines_of_code,
        
      
        

          
          
              :plain           => :text,
        
      
        

          
          
              :plaintext       => :text,
        
      
        

          
          
              :remove_comments => :comment_filter,
        
      
        

          
          
              :stats           => :statistic,
        
      
        

          
          
              :term            => :terminal,
        
      
        

          
          
              :tty             => :terminal,
        
      
        

          
          
              :yml             => :yaml
        
      
        

          
          
            
        
      
        

          
          
            # No default because Tokens#nonsense should raise NoMethodError.
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          1
          
            module Encoders
        
      
        

          
          
              
        
      
        

          
          
              # Outputs code highlighted for a color terminal.
        
      
        

          
          
              # 
        
      
        

          
          
              # Note: This encoder is in beta. It currently doesn't use the Styles.
        
      
        

          
          
              # 
        
      
        

          
          
              # Alias: +term+
        
      
        

          
          
              # 
        
      
        

          
          
              # == Authors & License
        
      
        

          
          
              # 
        
      
        

          
          
              # By Rob Aldred (http://robaldred.co.uk)
        
      
        

          
          
              # 
        
      
        

          
          
              # Based on idea by Nathan Weizenbaum (http://nex-3.com)
        
      
        

          
          
              # 
        
      
        

          
          
              # MIT License (http://www.opensource.org/licenses/mit-license.php)
        
      
        

          1
          
              class Terminal < Encoder
        
      
        

          
          
                
        
      
        

          1
          
                register_for :terminal
        
      
        

          
          
                
        
      
        

          1
          
                TOKEN_COLORS = {
        
      
        

          
          
                  :debug => "\e[1;37;44m",
        
      
        

          
          
                  
        
      
        

          
          
                  :annotation => "\e[34m",
        
      
        

          
          
                  :attribute_name => "\e[35m",
        
      
        

          
          
                  :attribute_value => "\e[31m",
        
      
        

          
          
                  :binary => {
        
      
        

          
          
                    :self => "\e[31m",
        
      
        

          
          
                    :char => "\e[1;31m",
        
      
        

          
          
                    :delimiter => "\e[1;31m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :char => {
        
      
        

          
          
                    :self => "\e[35m",
        
      
        

          
          
                    :delimiter => "\e[1;35m"
        
      
        

          
          
                  },
        
      
        

          
          
                  :class => "\e[1;35;4m",
        
      
        

          
          
                  :class_variable => "\e[36m",
        
      
        

          
          
                  :color => "\e[32m",
        
      
        

          
          
                  :comment => {
        
      
        

          
          
                    :self => "\e[1;30m",
        
      
        

          
          
                    :char => "\e[37m",
        
      
        

          
          
                    :delimiter => "\e[37m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :constant => "\e[1;34;4m",
        
      
        

          
          
                  :decorator => "\e[35m",
        
      
        

          
          
                  :definition => "\e[1;33m",
        
      
        

          
          
                  :directive => "\e[33m",
        
      
        

          
          
                  :docstring => "\e[31m",
        
      
        

          
          
                  :doctype => "\e[1;34m",
        
      
        

          
          
                  :done => "\e[1;30;2m",
        
      
        

          
          
                  :entity => "\e[31m",
        
      
        

          
          
                  :error => "\e[1;37;41m",
        
      
        

          
          
                  :exception => "\e[1;31m",
        
      
        

          
          
                  :float => "\e[1;35m",
        
      
        

          
          
                  :function => "\e[1;34m",
        
      
        

          
          
                  :global_variable => "\e[1;32m",
        
      
        

          
          
                  :hex => "\e[1;36m",
        
      
        

          
          
                  :id => "\e[1;34m",
        
      
        

          
          
                  :include => "\e[31m",
        
      
        

          
          
                  :integer => "\e[1;34m",
        
      
        

          
          
                  :imaginary => "\e[1;34m",
        
      
        

          
          
                  :important => "\e[1;31m",
        
      
        

          
          
                  :key => {
        
      
        

          
          
                    :self => "\e[35m",
        
      
        

          
          
                    :char => "\e[1;35m",
        
      
        

          
          
                    :delimiter => "\e[1;35m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :keyword => "\e[32m",
        
      
        

          
          
                  :label => "\e[1;33m",
        
      
        

          
          
                  :local_variable => "\e[33m",
        
      
        

          
          
                  :namespace => "\e[1;35m",
        
      
        

          
          
                  :octal => "\e[1;34m",
        
      
        

          
          
                  :predefined => "\e[36m",
        
      
        

          
          
                  :predefined_constant => "\e[1;36m",
        
      
        

          
          
                  :predefined_type => "\e[1;32m",
        
      
        

          
          
                  :preprocessor => "\e[1;36m",
        
      
        

          
          
                  :pseudo_class => "\e[1;34m",
        
      
        

          
          
                  :regexp => {
        
      
        

          
          
                    :self => "\e[35m",
        
      
        

          
          
                    :delimiter => "\e[1;35m",
        
      
        

          
          
                    :modifier => "\e[35m",
        
      
        

          
          
                    :char => "\e[1;35m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :reserved => "\e[32m",
        
      
        

          
          
                  :shell => {
        
      
        

          
          
                    :self => "\e[33m",
        
      
        

          
          
                    :char => "\e[1;33m",
        
      
        

          
          
                    :delimiter => "\e[1;33m",
        
      
        

          
          
                    :escape => "\e[1;33m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :string => {
        
      
        

          
          
                    :self => "\e[31m",
        
      
        

          
          
                    :modifier => "\e[1;31m",
        
      
        

          
          
                    :char => "\e[1;35m",
        
      
        

          
          
                    :delimiter => "\e[1;31m",
        
      
        

          
          
                    :escape => "\e[1;31m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :symbol => {
        
      
        

          
          
                    :self => "\e[33m",
        
      
        

          
          
                    :delimiter => "\e[1;33m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :tag => "\e[32m",
        
      
        

          
          
                  :type => "\e[1;34m",
        
      
        

          
          
                  :value => "\e[36m",
        
      
        

          
          
                  :variable => "\e[34m",
        
      
        

          
          
                  
        
      
        

          
          
                  :insert => {
        
      
        

          
          
                    :self => "\e[42m",
        
      
        

          
          
                    :insert => "\e[1;32;42m",
        
      
        

          
          
                    :eyecatcher => "\e[102m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :delete => {
        
      
        

          
          
                    :self => "\e[41m",
        
      
        

          
          
                    :delete => "\e[1;31;41m",
        
      
        

          
          
                    :eyecatcher => "\e[101m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :change => {
        
      
        

          
          
                    :self => "\e[44m",
        
      
        

          
          
                    :change => "\e[37;44m",
        
      
        

          
          
                  },
        
      
        

          
          
                  :head => {
        
      
        

          
          
                    :self => "\e[45m",
        
      
        

          
          
                    :filename => "\e[37;45m"
        
      
        

          
          
                  },
        
      
        

          
          
                }
        
      
        

          
          
                
        
      
        

          1
          
                TOKEN_COLORS[:keyword] = TOKEN_COLORS[:reserved]
        
      
        

          1
          
                TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
        
      
        

          1
          
                TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
        
      
        

          
          
                
        
      
        

          1
          
              protected
        
      
        

          
          
                
        
      
        

          1
          
                def setup(options)
        
      
        

          81
          
                  super
        
      
        

          81
          
                  @opened = []
        
      
        

          81
          
                  @color_scopes = [TOKEN_COLORS]
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
              public
        
      
        

          
          
                
        
      
        

          1
          
                def text_token text, kind
        
      
        

          479
          
                  if color = @color_scopes.last[kind]
        
      
        

          92
          
                    color = color[:self] if color.is_a? Hash
        
      
        

          
          
                    
        
      
        

          92
          
                    @out << color
        
      
        

          92
          
                    @out << (text.index("\n") ? text.gsub("\n", "\e[0m\n" + color) : text)
        
      
        

          92
          
                    @out << "\e[0m"
        
      
        

          92
          
                    if outer_color = @color_scopes.last[:self]
        
      
        

          40
          
                      @out << outer_color
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          387
          
                    @out << text
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def begin_group kind
        
      
        

          56
          
                  @opened << kind
        
      
        

          56
          
                  @out << open_token(kind)
        
      
        

          
          
                end
        
      
        

          1
          
                alias begin_line begin_group
        
      
        

          
          
                
        
      
        

          1
          
                def end_group kind
        
      
        

          56
          
                  if @opened.pop
        
      
        

          56
          
                    @color_scopes.pop
        
      
        

          56
          
                    @out << "\e[0m"
        
      
        

          56
          
                    if outer_color = @color_scopes.last[:self]
        
      
        

          36
          
                      @out << outer_color
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def end_line kind
        
      
        

          
          
                  @out << (@line_filler ||= "\t" * 100)
        
      
        

          
          
                  end_group kind
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
              private
        
      
        

          
          
                
        
      
        

          1
          
                def open_token kind
        
      
        

          56
          
                  if color = @color_scopes.last[kind]
        
      
        

          20
          
                    if color.is_a? Hash
        
      
        

          20
          
                      @color_scopes << color
        
      
        

          20
          
                      color[:self]
        
      
        

          
          
                    else
        
      
        

          
          
                      @color_scopes << @color_scopes.last
        
      
        

          
          
                      color
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          36
          
                    @color_scopes << @color_scopes.last
        
      
        

          36
          
                    ''
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          
          
            # = PluginHost
        
      
        

          
          
            #
        
      
        

          
          
            # A simple subclass/subfolder plugin system.
        
      
        

          
          
            #
        
      
        

          
          
            # Example:
        
      
        

          
          
            #  class Generators
        
      
        

          
          
            #    extend PluginHost
        
      
        

          
          
            #    plugin_path 'app/generators'
        
      
        

          
          
            #  end
        
      
        

          
          
            #  
        
      
        

          
          
            #  class Generator
        
      
        

          
          
            #    extend Plugin
        
      
        

          
          
            #    PLUGIN_HOST = Generators
        
      
        

          
          
            #  end
        
      
        

          
          
            #  
        
      
        

          
          
            #  class FancyGenerator < Generator
        
      
        

          
          
            #    register_for :fancy
        
      
        

          
          
            #  end
        
      
        

          
          
            #  
        
      
        

          
          
            #  Generators[:fancy]  #-> FancyGenerator
        
      
        

          
          
            #  # or
        
      
        

          
          
            #  CodeRay.require_plugin 'Generators/fancy'
        
      
        

          
          
            #  # or
        
      
        

          
          
            #  Generators::Fancy
        
      
        

          1
          
            module PluginHost
        
      
        

          
          
              
        
      
        

          
          
              # Raised if Encoders::[] fails because:
        
      
        

          
          
              # * a file could not be found
        
      
        

          
          
              # * the requested Plugin is not registered
        
      
        

          1
          
              PluginNotFound = Class.new LoadError
        
      
        

          1
          
              HostNotFound   = Class.new LoadError
        
      
        

          
          
              
        
      
        

          1
          
              PLUGIN_HOSTS = []
        
      
        

          1
          
              PLUGIN_HOSTS_BY_ID = {}  # dummy hash
        
      
        

          
          
              
        
      
        

          
          
              # Loads all plugins using list and load.
        
      
        

          1
          
              def load_all
        
      
        

          
          
                for plugin in list
        
      
        

          
          
                  load plugin
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Returns the Plugin for +id+.
        
      
        

          
          
              #
        
      
        

          
          
              # Example:
        
      
        

          
          
              #  yaml_plugin = MyPluginHost[:yaml]
        
      
        

          1
          
              def [] id, *args, &blk
        
      
        

          176
          
                plugin = validate_id(id)
        
      
        

          
          
                begin
        
      
        

          257
          
                  plugin = plugin_hash.[](plugin, *args, &blk)
        
      
        

          176
          
                end while plugin.is_a? String
        
      
        

          176
          
                plugin
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              alias load []
        
      
        

          
          
              
        
      
        

          
          
              # Tries to +load+ the missing plugin by translating +const+ to the
        
      
        

          
          
              # underscore form (eg. LinesOfCode becomes lines_of_code).
        
      
        

          1
          
              def const_missing const
        
      
        

          1
          
                id = const.to_s.
        
      
        

          
          
                  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
        
      
        

          
          
                  gsub(/([a-z\d])([A-Z])/,'\1_\2').
        
      
        

          
          
                  downcase
        
      
        

          1
          
                load id
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              class << self
        
      
        

          
          
                
        
      
        

          
          
                # Adds the module/class to the PLUGIN_HOSTS list.
        
      
        

          1
          
                def extended mod
        
      
        

          2
          
                  PLUGIN_HOSTS << mod
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # The path where the plugins can be found.
        
      
        

          1
          
              def plugin_path *args
        
      
        

          6
          
                unless args.empty?
        
      
        

          2
          
                  @plugin_path = File.expand_path File.join(*args)
        
      
        

          
          
                end
        
      
        

          6
          
                @plugin_path ||= ''
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Map a plugin_id to another.
        
      
        

          
          
              #
        
      
        

          
          
              # Usage: Put this in a file plugin_path/_map.rb.
        
      
        

          
          
              #
        
      
        

          
          
              #  class MyColorHost < PluginHost
        
      
        

          
          
              #    map :navy => :dark_blue,
        
      
        

          
          
              #      :maroon => :brown,
        
      
        

          
          
              #      :luna => :moon
        
      
        

          
          
              #  end
        
      
        

          1
          
              def map hash
        
      
        

          2
          
                for from, to in hash
        
      
        

          23
          
                  from = validate_id from
        
      
        

          23
          
                  to   = validate_id to
        
      
        

          23
          
                  plugin_hash[from] = to unless plugin_hash.has_key? from
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Define the default plugin to use when no plugin is found
        
      
        

          
          
              # for a given id, or return the default plugin.
        
      
        

          
          
              #
        
      
        

          
          
              # See also map.
        
      
        

          
          
              #
        
      
        

          
          
              #  class MyColorHost < PluginHost
        
      
        

          
          
              #    map :navy => :dark_blue
        
      
        

          
          
              #    default :gray
        
      
        

          
          
              #  end
        
      
        

          
          
              #  
        
      
        

          
          
              #  MyColorHost.default  # loads and returns the Gray plugin
        
      
        

          1
          
              def default id = nil
        
      
        

          1
          
                if id
        
      
        

          1
          
                  id = validate_id id
        
      
        

          1
          
                  raise "The default plugin can't be named \"default\"." if id == :default
        
      
        

          1
          
                  plugin_hash[:default] = id
        
      
        

          
          
                else
        
      
        

          
          
                  load :default
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Every plugin must register itself for +id+ by calling register_for,
        
      
        

          
          
              # which calls this method.
        
      
        

          
          
              #
        
      
        

          
          
              # See Plugin#register_for.
        
      
        

          1
          
              def register plugin, id
        
      
        

          2
          
                plugin_hash[validate_id(id)] = plugin
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # A Hash of plugion_id => Plugin pairs.
        
      
        

          1
          
              def plugin_hash
        
      
        

          308
          
                @plugin_hash ||= (@plugin_hash = make_plugin_hash).tap { load_plugin_map }
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Returns an array of all .rb files in the plugin path.
        
      
        

          
          
              #
        
      
        

          
          
              # The extension .rb is not included.
        
      
        

          1
          
              def list
        
      
        

          
          
                Dir[path_to('*')].select do |file|
        
      
        

          
          
                  File.basename(file)[/^(?!_)\w+\.rb$/]
        
      
        

          
          
                end.map do |file|
        
      
        

          
          
                  File.basename(file, '.rb').to_sym
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Returns an array of all Plugins.
        
      
        

          
          
              # 
        
      
        

          
          
              # Note: This loads all plugins using load_all.
        
      
        

          1
          
              def all_plugins
        
      
        

          
          
                load_all
        
      
        

          
          
                plugin_hash.values.grep(Class)
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Loads the map file (see map).
        
      
        

          
          
              #
        
      
        

          
          
              # This is done automatically when plugin_path is called.
        
      
        

          1
          
              def load_plugin_map
        
      
        

          2
          
                mapfile = path_to '_map'
        
      
        

          2
          
                if File.exist? mapfile
        
      
        

          2
          
                  require mapfile
        
      
        

          2
          
                  true
        
      
        

          
          
                else
        
      
        

          
          
                  false
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
            protected
        
      
        

          
          
              
        
      
        

          
          
              # Return a plugin hash that automatically loads plugins.
        
      
        

          1
          
              def make_plugin_hash
        
      
        

          2
          
                Hash.new do |h, plugin_id|
        
      
        

          2
          
                  id = validate_id(plugin_id)
        
      
        

          2
          
                  path = path_to id
        
      
        

          2
          
                  begin
        
      
        

          2
          
                    require path
        
      
        

          
          
                  rescue LoadError => boom
        
      
        

          
          
                    if h.has_key?(:default)
        
      
        

          
          
                      h[:default]
        
      
        

          
          
                    else
        
      
        

          
          
                      raise PluginNotFound, '%p could not load plugin %p: %s' % [self, id, boom]
        
      
        

          
          
                    end
        
      
        

          
          
                  else
        
      
        

          
          
                    # Plugin should have registered by now
        
      
        

          2
          
                    if h.has_key? id
        
      
        

          2
          
                      h[id]
        
      
        

          
          
                    else
        
      
        

          
          
                      raise PluginNotFound, "No #{self.name} plugin for #{id.inspect} found in #{path}."
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Returns the expected path to the plugin file for the given id.
        
      
        

          1
          
              def path_to plugin_id
        
      
        

          4
          
                File.join plugin_path, "#{plugin_id}.rb"
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Converts +id+ to a valid plugin ID String, or returns +nil+.
        
      
        

          
          
              #
        
      
        

          
          
              # Raises +ArgumentError+ for all other objects, or if the
        
      
        

          
          
              # given String includes non-alphanumeric characters (\W).
        
      
        

          1
          
              def validate_id id
        
      
        

          227
          
                case id
        
      
        

          
          
                when Symbol
        
      
        

          224
          
                  id.to_s
        
      
        

          
          
                when String
        
      
        

          3
          
                  if id[/\w+/] == id
        
      
        

          3
          
                    id.downcase
        
      
        

          
          
                  else
        
      
        

          
          
                    raise ArgumentError, "Invalid id given: #{id}"
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
                  raise ArgumentError, "Symbol or String expected, but #{id.class} given."
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
            
        
      
        

          
          
            # = Plugin
        
      
        

          
          
            #
        
      
        

          
          
            #  Plugins have to include this module.
        
      
        

          
          
            #
        
      
        

          
          
            #  IMPORTANT: Use extend for this module.
        
      
        

          
          
            #
        
      
        

          
          
            #  See CodeRay::PluginHost for examples.
        
      
        

          1
          
            module Plugin
        
      
        

          
          
              
        
      
        

          1
          
              attr_reader :plugin_id
        
      
        

          
          
              
        
      
        

          
          
              # Register this class for the given +id+.
        
      
        

          
          
              # 
        
      
        

          
          
              # Example:
        
      
        

          
          
              #   class MyPlugin < PluginHost::BaseClass
        
      
        

          
          
              #     register_for :my_id
        
      
        

          
          
              #     ...
        
      
        

          
          
              #   end
        
      
        

          
          
              #
        
      
        

          
          
              # See PluginHost.register.
        
      
        

          1
          
              def register_for id
        
      
        

          2
          
                @plugin_id = id
        
      
        

          2
          
                plugin_host.register self, id
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Returns the title of the plugin, or sets it to the
        
      
        

          
          
              # optional argument +title+.
        
      
        

          1
          
              def title title = nil
        
      
        

          
          
                if title
        
      
        

          
          
                  @title = title.to_s
        
      
        

          
          
                else
        
      
        

          
          
                  @title ||= name[/([^:]+)$/, 1]
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # The PluginHost for this Plugin class.
        
      
        

          1
          
              def plugin_host host = nil
        
      
        

          4
          
                if host.is_a? PluginHost
        
      
        

          2
          
                  const_set :PLUGIN_HOST, host
        
      
        

          
          
                end
        
      
        

          4
          
                self::PLUGIN_HOST
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              def aliases
        
      
        

          
          
                plugin_host.plugin_hash.inject [] do |aliases, (key, _)|
        
      
        

          
          
                  aliases << key if plugin_host[key] == self
        
      
        

          
          
                  aliases
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          
          
            # = WordList
        
      
        

          
          
            # 
        
      
        

          
          
            # <b>A Hash subclass designed for mapping word lists to token types.</b>
        
      
        

          
          
            # 
        
      
        

          
          
            # A WordList is a Hash with some additional features.
        
      
        

          
          
            # It is intended to be used for keyword recognition.
        
      
        

          
          
            #
        
      
        

          
          
            # WordList is optimized to be used in Scanners,
        
      
        

          
          
            # typically to decide whether a given ident is a special token.
        
      
        

          
          
            #
        
      
        

          
          
            # For case insensitive words use WordList::CaseIgnoring.
        
      
        

          
          
            #
        
      
        

          
          
            # Example:
        
      
        

          
          
            #
        
      
        

          
          
            #  # define word arrays
        
      
        

          
          
            #  RESERVED_WORDS = %w[
        
      
        

          
          
            #    asm break case continue default do else
        
      
        

          
          
            #  ]
        
      
        

          
          
            #  
        
      
        

          
          
            #  PREDEFINED_TYPES = %w[
        
      
        

          
          
            #    int long short char void
        
      
        

          
          
            #  ]
        
      
        

          
          
            #  
        
      
        

          
          
            #  # make a WordList
        
      
        

          
          
            #  IDENT_KIND = WordList.new(:ident).
        
      
        

          
          
            #    add(RESERVED_WORDS, :reserved).
        
      
        

          
          
            #    add(PREDEFINED_TYPES, :predefined_type)
        
      
        

          
          
            #  
        
      
        

          
          
            #  ...
        
      
        

          
          
            #  
        
      
        

          
          
            #  def scan_tokens tokens, options
        
      
        

          
          
            #    ...
        
      
        

          
          
            #    
        
      
        

          
          
            #    elsif scan(/[A-Za-z_][A-Za-z_0-9]*/)
        
      
        

          
          
            #      # use it
        
      
        

          
          
            #      kind = IDENT_KIND[match]
        
      
        

          
          
            #      ...
        
      
        

          1
          
            class WordList < Hash
        
      
        

          
          
              
        
      
        

          
          
              # Create a new WordList with +default+ as default value.
        
      
        

          1
          
              def initialize default = false
        
      
        

          3
          
                super default
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Add words to the list and associate them with +value+.
        
      
        

          
          
              # 
        
      
        

          
          
              # Returns +self+, so you can concat add calls.
        
      
        

          1
          
              def add words, value = true
        
      
        

          99
          
                words.each { |word| self[word] = value }
        
      
        

          7
          
                self
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
            
        
      
        

          
          
            # A CaseIgnoring WordList is like a WordList, only that
        
      
        

          
          
            # keys are compared case-insensitively (normalizing keys using +downcase+).
        
      
        

          1
          
            class WordList::CaseIgnoring < WordList
        
      
        

          
          
              
        
      
        

          1
          
              def [] key
        
      
        

          
          
                super key.downcase
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              def []= key, value
        
      
        

          
          
                super key.downcase, value
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # encoding: utf-8
        
      
        

          1
          
          require 'strscan'
        
      
        

          
          
          
        
      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          1
          
            autoload :WordList, coderay_path('helpers', 'word_list')
        
      
        

          
          
            
        
      
        

          
          
            # = Scanners
        
      
        

          
          
            #
        
      
        

          
          
            # This module holds the Scanner class and its subclasses.
        
      
        

          
          
            # For example, the Ruby scanner is named CodeRay::Scanners::Ruby
        
      
        

          
          
            # can be found in coderay/scanners/ruby.
        
      
        

          
          
            #
        
      
        

          
          
            # Scanner also provides methods and constants for the register
        
      
        

          
          
            # mechanism and the [] method that returns the Scanner class
        
      
        

          
          
            # belonging to the given lang.
        
      
        

          
          
            #
        
      
        

          
          
            # See PluginHost.
        
      
        

          1
          
            module Scanners
        
      
        

          1
          
              extend PluginHost
        
      
        

          1
          
              plugin_path File.dirname(__FILE__), 'scanners'
        
      
        

          
          
              
        
      
        

          
          
              
        
      
        

          
          
              # = Scanner
        
      
        

          
          
              #
        
      
        

          
          
              # The base class for all Scanners.
        
      
        

          
          
              #
        
      
        

          
          
              # It is a subclass of Ruby's great +StringScanner+, which
        
      
        

          
          
              # makes it easy to access the scanning methods inside.
        
      
        

          
          
              #
        
      
        

          
          
              # It is also +Enumerable+, so you can use it like an Array of
        
      
        

          
          
              # Tokens:
        
      
        

          
          
              #
        
      
        

          
          
              #   require 'coderay'
        
      
        

          
          
              #   
        
      
        

          
          
              #   c_scanner = CodeRay::Scanners[:c].new "if (*p == '{') nest++;"
        
      
        

          
          
              #   
        
      
        

          
          
              #   for text, kind in c_scanner
        
      
        

          
          
              #     puts text if kind == :operator
        
      
        

          
          
              #   end
        
      
        

          
          
              #   
        
      
        

          
          
              #   # prints: (*==)++;
        
      
        

          
          
              #
        
      
        

          
          
              # OK, this is a very simple example :)
        
      
        

          
          
              # You can also use +map+, +any?+, +find+ and even +sort_by+,
        
      
        

          
          
              # if you want.
        
      
        

          1
          
              class Scanner < StringScanner
        
      
        

          
          
                
        
      
        

          1
          
                extend Plugin
        
      
        

          1
          
                plugin_host Scanners
        
      
        

          
          
                
        
      
        

          
          
                # Raised if a Scanner fails while scanning
        
      
        

          1
          
                ScanError = Class.new StandardError
        
      
        

          
          
                
        
      
        

          
          
                # The default options for all scanner classes.
        
      
        

          
          
                #
        
      
        

          
          
                # Define @default_options for subclasses.
        
      
        

          1
          
                DEFAULT_OPTIONS = { }
        
      
        

          
          
                
        
      
        

          1
          
                KINDS_NOT_LOC = [:comment, :doctype, :docstring]
        
      
        

          
          
                
        
      
        

          1
          
                attr_accessor :state
        
      
        

          
          
                
        
      
        

          1
          
                class << self
        
      
        

          
          
                  
        
      
        

          
          
                  # Normalizes the given code into a string with UNIX newlines, in the
        
      
        

          
          
                  # scanner's internal encoding, with invalid and undefined charachters
        
      
        

          
          
                  # replaced by placeholders. Always returns a new object.
        
      
        

          1
          
                  def normalize code
        
      
        

          
          
                    # original = code
        
      
        

          120
          
                    code = code.to_s unless code.is_a? ::String
        
      
        

          120
          
                    return code if code.empty?
        
      
        

          
          
                    
        
      
        

          98
          
                    if code.respond_to? :encoding
        
      
        

          98
          
                      code = encode_with_encoding code, self.encoding
        
      
        

          
          
                    else
        
      
        

          
          
                      code = to_unix code
        
      
        

          
          
                    end
        
      
        

          
          
                    # code = code.dup if code.eql? original
        
      
        

          98
          
                    code
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                  # The typical filename suffix for this scanner's language.
        
      
        

          1
          
                  def file_extension extension = lang
        
      
        

          1
          
                    @file_extension ||= extension.to_s
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                  # The encoding used internally by this scanner.
        
      
        

          1
          
                  def encoding name = 'UTF-8'
        
      
        

          98
          
                    @encoding ||= defined?(Encoding.find) && Encoding.find(name)
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                  # The lang of this Scanner class, which is equal to its Plugin ID.
        
      
        

          1
          
                  def lang
        
      
        

          
          
                    @plugin_id
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          1
          
                protected
        
      
        

          
          
                  
        
      
        

          1
          
                  def encode_with_encoding code, target_encoding
        
      
        

          98
          
                    if code.encoding == target_encoding
        
      
        

          58
          
                      if code.valid_encoding?
        
      
        

          58
          
                        return to_unix(code)
        
      
        

          
          
                      else
        
      
        

          
          
                        source_encoding = guess_encoding code
        
      
        

          
          
                      end
        
      
        

          
          
                    else
        
      
        

          40
          
                      source_encoding = code.encoding
        
      
        

          
          
                    end
        
      
        

          
          
                    # print "encode_with_encoding from #{source_encoding} to #{target_encoding}"
        
      
        

          40
          
                    code.encode target_encoding, source_encoding, :universal_newline => true, :undef => :replace, :invalid => :replace
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          1
          
                  def to_unix code
        
      
        

          58
          
                    code.index(?\r) ? code.gsub(/\r\n?/, "\n") : code
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          1
          
                  def guess_encoding s
        
      
        

          
          
                    #:nocov:
        
      
        

          
          skipped
                    IO.popen("file -b --mime -", "w+") do |file|
        
      
        

          
          skipped
                      file.write s[0, 1024]
        
      
        

          
          skipped
                      file.close_write
        
      
        

          
          skipped
                      begin
        
      
        

          
          skipped
                        Encoding.find file.gets[/charset=([-\w]+)/, 1]
        
      
        

          
          skipped
                      rescue ArgumentError
        
      
        

          
          skipped
                        Encoding::BINARY
        
      
        

          
          skipped
                      end
        
      
        

          
          skipped
                    end
        
      
        

          
          
                    #:nocov:
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Create a new Scanner.
        
      
        

          
          
                #
        
      
        

          
          
                # * +code+ is the input String and is handled by the superclass
        
      
        

          
          
                #   StringScanner.
        
      
        

          
          
                # * +options+ is a Hash with Symbols as keys.
        
      
        

          
          
                #   It is merged with the default options of the class (you can
        
      
        

          
          
                #   overwrite default options here.)
        
      
        

          
          
                #
        
      
        

          
          
                # Else, a Tokens object is used.
        
      
        

          1
          
                def initialize code = '', options = {}
        
      
        

          94
          
                  if self.class == Scanner
        
      
        

          
          
                    raise NotImplementedError, "I am only the basic Scanner class. I can't scan anything. :( Use my subclasses."
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          94
          
                  @options = self.class::DEFAULT_OPTIONS.merge options
        
      
        

          
          
                  
        
      
        

          94
          
                  super self.class.normalize(code)
        
      
        

          
          
                  
        
      
        

          94
          
                  @tokens = options[:tokens] || Tokens.new
        
      
        

          94
          
                  @tokens.scanner = self if @tokens.respond_to? :scanner=
        
      
        

          
          
                  
        
      
        

          94
          
                  setup
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Sets back the scanner. Subclasses should redefine the reset_instance
        
      
        

          
          
                # method instead of this one.
        
      
        

          1
          
                def reset
        
      
        

          81
          
                  super
        
      
        

          81
          
                  reset_instance
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Set a new string to be scanned.
        
      
        

          1
          
                def string= code
        
      
        

          13
          
                  code = self.class.normalize(code)
        
      
        

          13
          
                  super code
        
      
        

          13
          
                  reset_instance
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # the Plugin ID for this scanner
        
      
        

          1
          
                def lang
        
      
        

          
          
                  self.class.lang
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # the default file extension for this scanner
        
      
        

          1
          
                def file_extension
        
      
        

          
          
                  self.class.file_extension
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Scan the code and returns all tokens in a Tokens object.
        
      
        

          1
          
                def tokenize source = nil, options = {}
        
      
        

          94
          
                  options = @options.merge(options)
        
      
        

          
          
                  
        
      
        

          94
          
                  set_tokens_from_options options
        
      
        

          94
          
                  set_string_from_source source
        
      
        

          
          
                  
        
      
        

          94
          
                  begin
        
      
        

          94
          
                    scan_tokens @tokens, options
        
      
        

          
          
                  rescue => e
        
      
        

          
          
                    message = "Error in %s#scan_tokens, initial state was: %p" % [self.class, defined?(state) && state]
        
      
        

          
          
                    raise_inspect e.message, @tokens, message, 30, e.backtrace
        
      
        

          
          
                  end
        
      
        

          
          
                  
        
      
        

          94
          
                  @cached_tokens = @tokens
        
      
        

          94
          
                  if source.is_a? Array
        
      
        

          
          
                    @tokens.split_into_parts(*source.map { |part| part.size })
        
      
        

          
          
                  else
        
      
        

          94
          
                    @tokens
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Cache the result of tokenize.
        
      
        

          1
          
                def tokens
        
      
        

          
          
                  @cached_tokens ||= tokenize
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Traverse the tokens.
        
      
        

          1
          
                def each &block
        
      
        

          
          
                  tokens.each(&block)
        
      
        

          
          
                end
        
      
        

          1
          
                include Enumerable
        
      
        

          
          
                
        
      
        

          
          
                # The current line position of the scanner, starting with 1.
        
      
        

          
          
                # See also: #column.
        
      
        

          
          
                #
        
      
        

          
          
                # Beware, this is implemented inefficiently. It should be used
        
      
        

          
          
                # for debugging only.
        
      
        

          1
          
                def line pos = self.pos
        
      
        

          
          
                  return 1 if pos <= 0
        
      
        

          
          
                  binary_string[0...pos].count("\n") + 1
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # The current column position of the scanner, starting with 1.
        
      
        

          
          
                # See also: #line.
        
      
        

          1
          
                def column pos = self.pos
        
      
        

          
          
                  return 1 if pos <= 0
        
      
        

          
          
                  pos - (binary_string.rindex(?\n, pos - 1) || -1)
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # The string in binary encoding.
        
      
        

          
          
                # 
        
      
        

          
          
                # To be used with #pos, which is the index of the byte the scanner
        
      
        

          
          
                # will scan next.
        
      
        

          1
          
                def binary_string
        
      
        

          
          
                  @binary_string ||=
        
      
        

          
          
                    if string.respond_to?(:bytesize) && string.bytesize != string.size
        
      
        

          
          
                      #:nocov:
        
      
        

          
          skipped
                      string.dup.force_encoding('binary')
        
      
        

          
          
                      #:nocov:
        
      
        

          
          
                    else
        
      
        

          
          
                      string
        
      
        

          
          
                    end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
              protected
        
      
        

          
          
                
        
      
        

          
          
                # Can be implemented by subclasses to do some initialization
        
      
        

          
          
                # that has to be done once per instance.
        
      
        

          
          
                #
        
      
        

          
          
                # Use reset for initialization that has to be done once per
        
      
        

          
          
                # scan.
        
      
        

          1
          
                def setup  # :doc:
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def set_string_from_source source
        
      
        

          94
          
                  case source
        
      
        

          
          
                  when Array
        
      
        

          
          
                    self.string = self.class.normalize(source.join)
        
      
        

          
          
                  when nil
        
      
        

          81
          
                    reset
        
      
        

          
          
                  else
        
      
        

          13
          
                    self.string = self.class.normalize(source)
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def set_tokens_from_options options
        
      
        

          94
          
                  @tokens = options[:tokens] || @tokens || Tokens.new
        
      
        

          94
          
                  @tokens.scanner = self if @tokens.respond_to? :scanner=
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # This is the central method, and commonly the only one a
        
      
        

          
          
                # subclass implements.
        
      
        

          
          
                #
        
      
        

          
          
                # Subclasses must implement this method; it must return +tokens+
        
      
        

          
          
                # and must only use Tokens#<< for storing scanned tokens!
        
      
        

          1
          
                def scan_tokens tokens, options  # :doc:
        
      
        

          
          
                  raise NotImplementedError, "#{self.class}#scan_tokens not implemented."
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Resets the scanner.
        
      
        

          1
          
                def reset_instance
        
      
        

          94
          
                  @tokens.clear if @tokens.respond_to?(:clear) && !@options[:keep_tokens]
        
      
        

          94
          
                  @cached_tokens = nil
        
      
        

          94
          
                  @binary_string = nil if defined? @binary_string
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                SCAN_ERROR_MESSAGE = <<-MESSAGE
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          ***ERROR in %s: %s (after %s tokens)
        
      
        

          
          
          
        
      
        

          
          
          tokens:
        
      
        

          
          
          %s
        
      
        

          
          
          
        
      
        

          
          
          %s
        
      
        

          
          
          
        
      
        

          
          
          surrounding code:
        
      
        

          
          
          %p  ~~  %p
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
          ***ERROR***
        
      
        

          
          
          
        
      
        

          
          
                MESSAGE
        
      
        

          
          
                
        
      
        

          1
          
                def raise_inspect_arguments message, tokens, state, ambit
        
      
        

          
          
                  return File.basename(caller[0]),
        
      
        

          
          
                    message,
        
      
        

          
          
                    tokens_size(tokens),
        
      
        

          
          
                    tokens_last(tokens, 10).map(&:inspect).join("\n"),
        
      
        

          
          
                    scanner_state_info(state),
        
      
        

          
          
                    binary_string[pos - ambit, ambit],
        
      
        

          
          
                    binary_string[pos, ambit]
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                SCANNER_STATE_INFO = <<-INFO
        
      
        

          
          
          current line: %d  column: %d  pos: %d
        
      
        

          
          
          matched: %p  state: %p
        
      
        

          
          
          bol?: %p,  eos?: %p
        
      
        

          
          
                INFO
        
      
        

          
          
                
        
      
        

          1
          
                def scanner_state_info state
        
      
        

          
          
                  SCANNER_STATE_INFO % [
        
      
        

          
          
                    line, column, pos,
        
      
        

          
          
                    matched, state || 'No state given!',
        
      
        

          
          
                    bol?, eos?,
        
      
        

          
          
                  ]
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Scanner error with additional status information
        
      
        

          1
          
                def raise_inspect message, tokens, state = self.state, ambit = 30, backtrace = caller
        
      
        

          
          
                  raise ScanError, SCAN_ERROR_MESSAGE % raise_inspect_arguments(message, tokens, state, ambit), backtrace
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def tokens_size tokens
        
      
        

          
          
                  tokens.size if tokens.respond_to?(:size)
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def tokens_last tokens, n
        
      
        

          
          
                  tokens.respond_to?(:last) ? tokens.last(n) : []
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # Shorthand for scan_until(/\z/).
        
      
        

          
          
                # This method also avoids a JRuby 1.9 mode bug.
        
      
        

          1
          
                def scan_rest
        
      
        

          
          
                  rest = self.rest
        
      
        

          
          
                  terminate
        
      
        

          
          
                  rest
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          1
          
          module Scanners
        
      
        

          
          
            
        
      
        

          1
          
            map \
        
      
        

          
          
              :'c++'       => :cpp,
        
      
        

          
          
              :cplusplus   => :cpp,
        
      
        

          
          
              :ecmascript  => :java_script,
        
      
        

          
          
              :ecma_script => :java_script,
        
      
        

          
          
              :rhtml       => :erb,
        
      
        

          
          
              :eruby       => :erb,
        
      
        

          
          
              :irb         => :ruby,
        
      
        

          
          
              :javascript  => :java_script,
        
      
        

          
          
              :js          => :java_script,
        
      
        

          
          
              :pascal      => :delphi,
        
      
        

          
          
              :patch       => :diff,
        
      
        

          
          
              :plain       => :text,
        
      
        

          
          
              :plaintext   => :text,
        
      
        

          
          
              :xhtml       => :html,
        
      
        

          
          
              :yml         => :yaml
        
      
        

          
          
            
        
      
        

          1
          
            default :text
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          1
          
          module Scanners
        
      
        

          
          
            
        
      
        

          
          
            # This scanner is really complex, since Ruby _is_ a complex language!
        
      
        

          
          
            #
        
      
        

          
          
            # It tries to highlight 100% of all common code,
        
      
        

          
          
            # and 90% of strange codes.
        
      
        

          
          
            #
        
      
        

          
          
            # It is optimized for HTML highlighting, and is not very useful for
        
      
        

          
          
            # parsing or pretty printing.
        
      
        

          1
          
            class Ruby < Scanner
        
      
        

          
          
              
        
      
        

          1
          
              register_for :ruby
        
      
        

          1
          
              file_extension 'rb'
        
      
        

          
          
              
        
      
        

          1
          
              autoload :Patterns,    CodeRay.coderay_path('scanners', 'ruby', 'patterns')
        
      
        

          1
          
              autoload :StringState, CodeRay.coderay_path('scanners', 'ruby', 'string_state')
        
      
        

          
          
              
        
      
        

          1
          
              def interpreted_string_state
        
      
        

          
          
                StringState.new :string, true, '"'
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
            protected
        
      
        

          
          
              
        
      
        

          1
          
              def setup
        
      
        

          94
          
                @state = :initial
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              def scan_tokens encoder, options
        
      
        

          94
          
                state, heredocs = options[:state] || @state
        
      
        

          94
          
                heredocs = heredocs.dup if heredocs.is_a?(Array)
        
      
        

          
          
                
        
      
        

          94
          
                if state && state.instance_of?(StringState)
        
      
        

          
          
                  encoder.begin_group state.type
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          94
          
                last_state = nil
        
      
        

          
          
                
        
      
        

          94
          
                method_call_expected = false
        
      
        

          94
          
                value_expected = true
        
      
        

          
          
                
        
      
        

          94
          
                inline_block_stack = nil
        
      
        

          94
          
                inline_block_curly_depth = 0
        
      
        

          
          
                
        
      
        

          94
          
                if heredocs
        
      
        

          
          
                  state = heredocs.shift
        
      
        

          
          
                  encoder.begin_group state.type
        
      
        

          
          
                  heredocs = nil if heredocs.empty?
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
                # def_object_stack = nil
        
      
        

          
          
                # def_object_paren_depth = 0
        
      
        

          
          
                
        
      
        

          94
          
                patterns = Patterns  # avoid constant lookup
        
      
        

          
          
                
        
      
        

          94
          
                unicode = string.respond_to?(:encoding) && string.encoding.name == 'UTF-8'
        
      
        

          
          
                
        
      
        

          94
          
                until eos?
        
      
        

          
          
                  
        
      
        

          517
          
                  if state.instance_of? ::Symbol
        
      
        

          
          
                    
        
      
        

          457
          
                    if match = scan(/[ \t\f\v]+/)
        
      
        

          83
          
                      encoder.text_token match, :space
        
      
        

          
          
                      
        
      
        

          
          
                    elsif match = scan(/\n/)
        
      
        

          
          
                      if heredocs
        
      
        

          
          
                        unscan  # heredoc scanning needs \n at start
        
      
        

          
          
                        state = heredocs.shift
        
      
        

          
          
                        encoder.begin_group state.type
        
      
        

          
          
                        heredocs = nil if heredocs.empty?
        
      
        

          
          
                      else
        
      
        

          
          
                        state = :initial if state == :undef_comma_expected
        
      
        

          
          
                        encoder.text_token match, :space
        
      
        

          
          
                        value_expected = true
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif match = scan(bol? ? / \#(!)?.* | #{patterns::RUBYDOC_OR_DATA} /ox : /\#.*/)
        
      
        

          
          
                      encoder.text_token match, self[1] ? :doctype : :comment
        
      
        

          
          
                      
        
      
        

          
          
                    elsif match = scan(/\\\n/)
        
      
        

          
          
                      if heredocs
        
      
        

          
          
                        unscan  # heredoc scanning needs \n at start
        
      
        

          
          
                        encoder.text_token scan(/\\/), :space
        
      
        

          
          
                        state = heredocs.shift
        
      
        

          
          
                        encoder.begin_group state.type
        
      
        

          
          
                        heredocs = nil if heredocs.empty?
        
      
        

          
          
                      else
        
      
        

          
          
                        encoder.text_token match, :space
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :initial
        
      
        

          
          
                      
        
      
        

          
          
                      # IDENTS #
        
      
        

          
          
                      if !method_call_expected &&
        
      
        

          
          
                         match = scan(unicode ? /#{patterns::METHOD_NAME}/uo :
        
      
        

          369
          
                                                /#{patterns::METHOD_NAME}/o)
        
      
        

          
          
                        
        
      
        

          98
          
                        kind = patterns::IDENT_KIND[match]
        
      
        

          98
          
                        if value_expected != :colon_expected && scan(/:(?!:)/)
        
      
        

          
          
                          value_expected = true
        
      
        

          
          
                          encoder.text_token match, :key
        
      
        

          
          
                          encoder.text_token ':',   :operator
        
      
        

          
          
                        else
        
      
        

          98
          
                          value_expected = false
        
      
        

          98
          
                          if kind == :ident
        
      
        

          88
          
                            if match[/\A[A-Z]/] && !(match[/[!?]$/] || match?(/\(/))
        
      
        

          
          
                              kind = :constant
        
      
        

          
          
                            end
        
      
        

          
          
                          elsif kind == :keyword
        
      
        

          10
          
                            state = patterns::KEYWORD_NEW_STATE[match]
        
      
        

          10
          
                            if patterns::KEYWORDS_EXPECTING_VALUE[match]
        
      
        

          5
          
                              value_expected = match == 'when' ? :colon_expected : true
        
      
        

          
          
                            end
        
      
        

          
          
                          end
        
      
        

          98
          
                          value_expected = true if !value_expected && check(/#{patterns::VALUE_FOLLOWS}/o)
        
      
        

          98
          
                          encoder.text_token match, kind
        
      
        

          
          
                        end
        
      
        

          
          
                        
        
      
        

          
          
                      elsif method_call_expected &&
        
      
        

          
          
                         match = scan(unicode ? /#{patterns::METHOD_AFTER_DOT}/uo :
        
      
        

          
          
                                                /#{patterns::METHOD_AFTER_DOT}/o)
        
      
        

          5
          
                        if method_call_expected == '::' && match[/\A[A-Z]/] && !match?(/\(/)
        
      
        

          
          
                          encoder.text_token match, :constant
        
      
        

          
          
                        else
        
      
        

          5
          
                          encoder.text_token match, :ident
        
      
        

          
          
                        end
        
      
        

          5
          
                        method_call_expected = false
        
      
        

          5
          
                        value_expected = check(/#{patterns::VALUE_FOLLOWS}/o)
        
      
        

          
          
                        
        
      
        

          
          
                      # OPERATORS #
        
      
        

          
          
                      elsif !method_call_expected && match = scan(/ (\.(?!\.)|::) | ( \.\.\.? | ==?=? | [,\(\[\{] ) | [\)\]\}] /x)
        
      
        

          156
          
                        method_call_expected = self[1]
        
      
        

          156
          
                        value_expected = !method_call_expected && !!self[2]
        
      
        

          156
          
                        if inline_block_stack
        
      
        

          135
          
                          case match
        
      
        

          
          
                          when '{'
        
      
        

          
          
                            inline_block_curly_depth += 1
        
      
        

          
          
                          when '}'
        
      
        

          45
          
                            inline_block_curly_depth -= 1
        
      
        

          45
          
                            if inline_block_curly_depth == 0  # closing brace of inline block reached
        
      
        

          45
          
                              state, inline_block_curly_depth, heredocs = inline_block_stack.pop
        
      
        

          45
          
                              inline_block_stack = nil if inline_block_stack.empty?
        
      
        

          45
          
                              heredocs = nil if heredocs && heredocs.empty?
        
      
        

          45
          
                              encoder.text_token match, :inline_delimiter
        
      
        

          45
          
                              encoder.end_group :inline
        
      
        

          45
          
                              next
        
      
        

          
          
                            end
        
      
        

          
          
                          end
        
      
        

          
          
                        end
        
      
        

          111
          
                        encoder.text_token match, :operator
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(unicode ? /#{patterns::SYMBOL}/uo :
        
      
        

          
          
                                                   /#{patterns::SYMBOL}/o)
        
      
        

          1
          
                        case delim = match[1]
        
      
        

          
          
                        when ?', ?"
        
      
        

          
          
                          encoder.begin_group :symbol
        
      
        

          
          
                          encoder.text_token ':', :symbol
        
      
        

          
          
                          match = delim.chr
        
      
        

          
          
                          encoder.text_token match, :delimiter
        
      
        

          
          
                          state = self.class::StringState.new :symbol, delim == ?", match
        
      
        

          
          
                        else
        
      
        

          1
          
                          encoder.text_token match, :symbol
        
      
        

          1
          
                          value_expected = false
        
      
        

          
          
                        end
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(/ ' (?:(?>[^'\\]*) ')? | " (?:(?>[^"\\\#]*) ")? /mx)
        
      
        

          25
          
                        encoder.begin_group :string
        
      
        

          25
          
                        if match.size == 1
        
      
        

          15
          
                          encoder.text_token match, :delimiter
        
      
        

          15
          
                          state = self.class::StringState.new :string, match == '"', match  # important for streaming
        
      
        

          
          
                        else
        
      
        

          10
          
                          encoder.text_token match[0,1], :delimiter
        
      
        

          10
          
                          encoder.text_token match[1..-2], :content if match.size > 2
        
      
        

          10
          
                          encoder.text_token match[-1,1], :delimiter
        
      
        

          10
          
                          encoder.end_group :string
        
      
        

          10
          
                          value_expected = false
        
      
        

          
          
                        end
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(unicode ? /#{patterns::INSTANCE_VARIABLE}/uo :
        
      
        

          
          
                                                   /#{patterns::INSTANCE_VARIABLE}/o)
        
      
        

          
          
                        value_expected = false
        
      
        

          
          
                        encoder.text_token match, :instance_variable
        
      
        

          
          
                        
        
      
        

          
          
                      elsif value_expected && match = scan(/\//)
        
      
        

          
          
                        encoder.begin_group :regexp
        
      
        

          
          
                        encoder.text_token match, :delimiter
        
      
        

          
          
                        state = self.class::StringState.new :regexp, true, '/'
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(value_expected ? /[-+]?#{patterns::NUMERIC}/o : /#{patterns::NUMERIC}/o)
        
      
        

          84
          
                        if method_call_expected
        
      
        

          
          
                          encoder.text_token match, :error
        
      
        

          
          
                          method_call_expected = false
        
      
        

          
          
                        else
        
      
        

          84
          
                          encoder.text_token match, self[1] ? :float : :integer  # TODO: send :hex/:octal/:binary
        
      
        

          
          
                        end
        
      
        

          84
          
                        value_expected = false
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(/ [-+!~^\/]=? | [:;] | [*|&]{1,2}=? | >>? /x)
        
      
        

          
          
                        value_expected = true
        
      
        

          
          
                        encoder.text_token match, :operator
        
      
        

          
          
                        
        
      
        

          
          
                      elsif value_expected && match = scan(/#{patterns::HEREDOC_OPEN}/o)
        
      
        

          
          
                        quote = self[3]
        
      
        

          
          
                        delim = self[quote ? 4 : 2]
        
      
        

          
          
                        kind = patterns::QUOTE_TO_TYPE[quote]
        
      
        

          
          
                        encoder.begin_group kind
        
      
        

          
          
                        encoder.text_token match, :delimiter
        
      
        

          
          
                        encoder.end_group kind
        
      
        

          
          
                        heredocs ||= []  # create heredocs if empty
        
      
        

          
          
                        heredocs << self.class::StringState.new(kind, quote != "'", delim,
        
      
        

          
          
                          self[1] == '-' ? :indented : :linestart)
        
      
        

          
          
                        value_expected = false
        
      
        

          
          
                        
        
      
        

          
          
                      elsif value_expected && match = scan(/#{patterns::FANCY_STRING_START}/o)
        
      
        

          
          
                        kind = patterns::FANCY_STRING_KIND[self[1]]
        
      
        

          
          
                        encoder.begin_group kind
        
      
        

          
          
                        state = self.class::StringState.new kind, patterns::FANCY_STRING_INTERPRETED[self[1]], self[2]
        
      
        

          
          
                        encoder.text_token match, :delimiter
        
      
        

          
          
                        
        
      
        

          
          
                      elsif value_expected && match = scan(/#{patterns::CHARACTER}/o)
        
      
        

          
          
                        value_expected = false
        
      
        

          
          
                        encoder.text_token match, :integer
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(/ %=? | <(?:<|=>?)? | \? /x)
        
      
        

          
          
                        value_expected = match == '?' ? :colon_expected : true
        
      
        

          
          
                        encoder.text_token match, :operator
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(/`/)
        
      
        

          
          
                        encoder.begin_group :shell
        
      
        

          
          
                        encoder.text_token match, :delimiter
        
      
        

          
          
                        state = self.class::StringState.new :shell, true, match
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(unicode ? /#{patterns::GLOBAL_VARIABLE}/uo :
        
      
        

          
          
                                                   /#{patterns::GLOBAL_VARIABLE}/o)
        
      
        

          
          
                        encoder.text_token match, :global_variable
        
      
        

          
          
                        value_expected = false
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(unicode ? /#{patterns::CLASS_VARIABLE}/uo :
        
      
        

          
          
                                                   /#{patterns::CLASS_VARIABLE}/o)
        
      
        

          
          
                        encoder.text_token match, :class_variable
        
      
        

          
          
                        value_expected = false
        
      
        

          
          
                        
        
      
        

          
          
                      elsif match = scan(/\\\z/)
        
      
        

          
          
                        encoder.text_token match, :space
        
      
        

          
          
                        
        
      
        

          
          
                      else
        
      
        

          
          
                        if method_call_expected
        
      
        

          
          
                          method_call_expected = false
        
      
        

          
          
                          next
        
      
        

          
          
                        end
        
      
        

          
          
                        unless unicode
        
      
        

          
          
                          # check for unicode
        
      
        

          
          
                          $DEBUG_BEFORE, $DEBUG = $DEBUG, false
        
      
        

          
          
                          begin
        
      
        

          
          
                            if check(/./mu).size > 1
        
      
        

          
          
                              # seems like we should try again with unicode
        
      
        

          
          
                              unicode = true
        
      
        

          
          
                            end
        
      
        

          
          
                          rescue
        
      
        

          
          
                            # bad unicode char; use getch
        
      
        

          
          
                          ensure
        
      
        

          
          
                            $DEBUG = $DEBUG_BEFORE
        
      
        

          
          
                          end
        
      
        

          
          
                          next if unicode
        
      
        

          
          
                        end
        
      
        

          
          
                        
        
      
        

          
          
                        encoder.text_token getch, :error
        
      
        

          
          
                        
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          324
          
                      if last_state
        
      
        

          
          
                        state = last_state unless state.is_a?(StringState)  # otherwise, a simple 'def"' results in unclosed tokens
        
      
        

          
          
                        last_state = nil
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :def_expected
        
      
        

          5
          
                      if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
        
      
        

          
          
                                                /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
        
      
        

          5
          
                        encoder.text_token match, :method
        
      
        

          5
          
                        state = :initial
        
      
        

          
          
                      else
        
      
        

          
          
                        last_state = :dot_expected
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :dot_expected
        
      
        

          
          
                      if match = scan(/\.|::/)
        
      
        

          
          
                        # invalid definition
        
      
        

          
          
                        state = :def_expected
        
      
        

          
          
                        encoder.text_token match, :operator
        
      
        

          
          
                      else
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :module_expected
        
      
        

          
          
                      if match = scan(/<</)
        
      
        

          
          
                        encoder.text_token match, :operator
        
      
        

          
          
                      else
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                        if match = scan(unicode ? / (?:#{patterns::IDENT}::)* #{patterns::IDENT} /oux :
        
      
        

          
          
                                                  / (?:#{patterns::IDENT}::)* #{patterns::IDENT} /ox)
        
      
        

          
          
                          encoder.text_token match, :class
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :undef_expected
        
      
        

          
          
                      state = :undef_comma_expected
        
      
        

          
          
                      if match = scan(unicode ? /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/uo :
        
      
        

          
          
                                                /(?>#{patterns::METHOD_NAME_EX})(?!\.|::)/o)
        
      
        

          
          
                        encoder.text_token match, :method
        
      
        

          
          
                      elsif match = scan(/#{patterns::SYMBOL}/o)
        
      
        

          
          
                        case delim = match[1]
        
      
        

          
          
                        when ?', ?"
        
      
        

          
          
                          encoder.begin_group :symbol
        
      
        

          
          
                          encoder.text_token ':', :symbol
        
      
        

          
          
                          match = delim.chr
        
      
        

          
          
                          encoder.text_token match, :delimiter
        
      
        

          
          
                          state = self.class::StringState.new :symbol, delim == ?", match
        
      
        

          
          
                          state.next_state = :undef_comma_expected
        
      
        

          
          
                        else
        
      
        

          
          
                          encoder.text_token match, :symbol
        
      
        

          
          
                        end
        
      
        

          
          
                      else
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :undef_comma_expected
        
      
        

          
          
                      if match = scan(/,/)
        
      
        

          
          
                        encoder.text_token match, :operator
        
      
        

          
          
                        state = :undef_expected
        
      
        

          
          
                      else
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    elsif state == :alias_expected
        
      
        

          
          
                      match = scan(unicode ? /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/uo :
        
      
        

          
          
                                             /(#{patterns::METHOD_NAME_OR_SYMBOL})([ \t]+)(#{patterns::METHOD_NAME_OR_SYMBOL})/o)
        
      
        

          
          
                      
        
      
        

          
          
                      if match
        
      
        

          
          
                        encoder.text_token self[1], (self[1][0] == ?: ? :symbol : :method)
        
      
        

          
          
                        encoder.text_token self[2], :space
        
      
        

          
          
                        encoder.text_token self[3], (self[3][0] == ?: ? :symbol : :method)
        
      
        

          
          
                      end
        
      
        

          
          
                      state = :initial
        
      
        

          
          
                      
        
      
        

          
          
                    else
        
      
        

          
          
                      #:nocov:
        
      
        

          
          skipped
                      raise_inspect 'Unknown state: %p' % [state], encoder
        
      
        

          
          
                      #:nocov:
        
      
        

          
          
                    end
        
      
        

          
          
                    
        
      
        

          
          
                  else  # StringState
        
      
        

          
          
                    
        
      
        

          60
          
                    match = scan_until(state.pattern) || scan_rest
        
      
        

          60
          
                    unless match.empty?
        
      
        

          60
          
                      encoder.text_token match, :content
        
      
        

          60
          
                      break if eos?
        
      
        

          
          
                    end
        
      
        

          
          
                    
        
      
        

          60
          
                    if state.heredoc && self[1]  # end of heredoc
        
      
        

          
          
                      match = getch
        
      
        

          
          
                      match << scan_until(/$/) unless eos?
        
      
        

          
          
                      encoder.text_token match, :delimiter unless match.empty?
        
      
        

          
          
                      encoder.end_group state.type
        
      
        

          
          
                      state = state.next_state
        
      
        

          
          
                      next
        
      
        

          
          
                    end
        
      
        

          
          
                    
        
      
        

          60
          
                    case match = getch
        
      
        

          
          
                    
        
      
        

          
          
                    when state.delim
        
      
        

          15
          
                      if state.paren_depth
        
      
        

          
          
                        state.paren_depth -= 1
        
      
        

          
          
                        if state.paren_depth > 0
        
      
        

          
          
                          encoder.text_token match, :content
        
      
        

          
          
                          next
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          15
          
                      encoder.text_token match, :delimiter
        
      
        

          15
          
                      if state.type == :regexp && !eos?
        
      
        

          
          
                        match = scan(/#{patterns::REGEXP_MODIFIERS}/o)
        
      
        

          
          
                        encoder.text_token match, :modifier unless match.empty?
        
      
        

          
          
                      end
        
      
        

          15
          
                      encoder.end_group state.type
        
      
        

          15
          
                      value_expected = false
        
      
        

          15
          
                      state = state.next_state
        
      
        

          
          
                      
        
      
        

          
          
                    when '\\'
        
      
        

          
          
                      if state.interpreted
        
      
        

          
          
                        if esc = scan(/#{patterns::ESCAPE}/o)
        
      
        

          
          
                          encoder.text_token match + esc, :char
        
      
        

          
          
                        else
        
      
        

          
          
                          encoder.text_token match, :error
        
      
        

          
          
                        end
        
      
        

          
          
                      else
        
      
        

          
          
                        case esc = getch
        
      
        

          
          
                        when nil
        
      
        

          
          
                          encoder.text_token match, :content
        
      
        

          
          
                        when state.delim, '\\'
        
      
        

          
          
                          encoder.text_token match + esc, :char
        
      
        

          
          
                        else
        
      
        

          
          
                          encoder.text_token match + esc, :content
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    when '#'
        
      
        

          45
          
                      case peek(1)
        
      
        

          
          
                      when '{'
        
      
        

          45
          
                        inline_block_stack ||= []
        
      
        

          45
          
                        inline_block_stack << [state, inline_block_curly_depth, heredocs]
        
      
        

          45
          
                        value_expected = true
        
      
        

          45
          
                        state = :initial
        
      
        

          45
          
                        inline_block_curly_depth = 1
        
      
        

          45
          
                        encoder.begin_group :inline
        
      
        

          45
          
                        encoder.text_token match + getch, :inline_delimiter
        
      
        

          
          
                      when '$', '@'
        
      
        

          
          
                        encoder.text_token match, :escape
        
      
        

          
          
                        last_state = state
        
      
        

          
          
                        state = :initial
        
      
        

          
          
                      else
        
      
        

          
          
                        #:nocov:
        
      
        

          
          skipped
                        raise_inspect 'else-case # reached; #%p not handled' % [peek(1)], encoder
        
      
        

          
          
                        #:nocov:
        
      
        

          
          
                      end
        
      
        

          
          
                      
        
      
        

          
          
                    when state.opening_paren
        
      
        

          
          
                      state.paren_depth += 1
        
      
        

          
          
                      encoder.text_token match, :content
        
      
        

          
          
                      
        
      
        

          
          
                    else
        
      
        

          
          
                      #:nocov
        
      
        

          
          
                      raise_inspect 'else-case " reached; %p not handled, state = %p' % [match, state], encoder
        
      
        

          
          
                      #:nocov:
        
      
        

          
          skipped
                      
        
      
        

          
          skipped
                    end
        
      
        

          
          skipped
                    
        
      
        

          
          skipped
                  end
        
      
        

          
          skipped
                  
        
      
        

          
          skipped
                end
        
      
        

          
          skipped
                
        
      
        

          
          skipped
                # cleaning up
        
      
        

          
          skipped
                if state.is_a? StringState
        
      
        

          
          skipped
                  encoder.end_group state.type
        
      
        

          
          skipped
                end
        
      
        

          
          skipped
                
        
      
        

          
          skipped
                if options[:keep_state]
        
      
        

          
          skipped
                  if state.is_a?(StringState) && state.heredoc
        
      
        

          
          skipped
                    (heredocs ||= []).unshift state
        
      
        

          
          skipped
                    state = :initial
        
      
        

          
          skipped
                  elsif heredocs && heredocs.empty?
        
      
        

          
          skipped
                    heredocs = nil
        
      
        

          
          skipped
                  end
        
      
        

          
          skipped
                  @state = state, heredocs
        
      
        

          
          skipped
                end
        
      
        

          
          skipped
                
        
      
        

          
          skipped
                if inline_block_stack
        
      
        

          
          skipped
                  until inline_block_stack.empty?
        
      
        

          
          skipped
                    state, = *inline_block_stack.pop
        
      
        

          
          skipped
                    encoder.end_group :inline
        
      
        

          
          skipped
                    encoder.end_group state.type
        
      
        

          
          skipped
                  end
        
      
        

          
          skipped
                end
        
      
        

          
          skipped
                
        
      
        

          
          skipped
                encoder
        
      
        

          
          skipped
              end
        
      
        

          
          skipped
              
        
      
        

          
          skipped
            end
        
      
        

          
          skipped
            
        
      
        

          
          skipped
          end
        
      
        

          
          skipped
          end
        
      
    
  

    

      
        

          
          
          # encoding: utf-8
        
      
        

          1
          
          module CodeRay
        
      
        

          1
          
          module Scanners
        
      
        

          
          
            
        
      
        

          1
          
            module Ruby::Patterns  # :nodoc: all
        
      
        

          
          
              
        
      
        

          1
          
              KEYWORDS = %w[
        
      
        

          
          
                and def end in or unless begin
        
      
        

          
          
                defined? ensure module redo super until
        
      
        

          
          
                BEGIN break do next rescue then
        
      
        

          
          
                when END case else for retry
        
      
        

          
          
                while alias class elsif if not return
        
      
        

          
          
                undef yield
        
      
        

          
          
              ]
        
      
        

          
          
              
        
      
        

          
          
              # See http://murfy.de/ruby-constants.
        
      
        

          1
          
              PREDEFINED_CONSTANTS = %w[
        
      
        

          
          
                nil true false self
        
      
        

          
          
                DATA ARGV ARGF ENV
        
      
        

          
          
                FALSE TRUE NIL
        
      
        

          
          
                STDERR STDIN STDOUT
        
      
        

          
          
                TOPLEVEL_BINDING
        
      
        

          
          
                RUBY_COPYRIGHT RUBY_DESCRIPTION RUBY_ENGINE RUBY_PATCHLEVEL
        
      
        

          
          
                RUBY_PLATFORM RUBY_RELEASE_DATE RUBY_REVISION RUBY_VERSION
        
      
        

          
          
                __FILE__ __LINE__ __ENCODING__
        
      
        

          
          
              ]
        
      
        

          
          
              
        
      
        

          1
          
              IDENT_KIND = WordList.new(:ident).
        
      
        

          
          
                add(KEYWORDS, :keyword).
        
      
        

          
          
                add(PREDEFINED_CONSTANTS, :predefined_constant)
        
      
        

          
          
              
        
      
        

          1
          
              KEYWORD_NEW_STATE = WordList.new(:initial).
        
      
        

          
          
                add(%w[ def ], :def_expected).
        
      
        

          
          
                add(%w[ undef ], :undef_expected).
        
      
        

          
          
                add(%w[ alias ], :alias_expected).
        
      
        

          
          
                add(%w[ class module ], :module_expected)
        
      
        

          
          
              
        
      
        

          1
          
              IDENT = 'ä'[/[[:alpha:]]/] == 'ä' ? Regexp.new('[[:alpha:]_[^\0-\177]][[:alnum:]_[^\0-\177]]*') : /[^\W\d]\w*/
        
      
        

          
          
              
        
      
        

          1
          
              METHOD_NAME = / #{IDENT} [?!]? /ox
        
      
        

          1
          
              METHOD_NAME_OPERATOR = /
        
      
        

          
          
                \*\*?           # multiplication and power
        
      
        

          
          
                | [-+~]@?       # plus, minus, tilde with and without at sign
        
      
        

          
          
                | [\/%&|^`]     # division, modulo or format strings, and, or, xor, system
        
      
        

          
          
                | \[\]=?        # array getter and setter
        
      
        

          
          
                | << | >>       # append or shift left, shift right
        
      
        

          
          
                | <=?>? | >=?   # comparison, rocket operator
        
      
        

          
          
                | ===? | =~     # simple equality, case equality, match
        
      
        

          
          
                | ![~=@]?       # negation with and without at sign, not-equal and not-match
        
      
        

          
          
              /ox
        
      
        

          1
          
              METHOD_SUFFIX = / (?: [?!] | = (?![~>]|=(?!>)) ) /x
        
      
        

          1
          
              METHOD_NAME_EX = / #{IDENT} #{METHOD_SUFFIX}? | #{METHOD_NAME_OPERATOR} /ox
        
      
        

          1
          
              METHOD_AFTER_DOT = / #{IDENT} [?!]? | #{METHOD_NAME_OPERATOR} /ox
        
      
        

          1
          
              INSTANCE_VARIABLE = / @ #{IDENT} /ox
        
      
        

          1
          
              CLASS_VARIABLE = / @@ #{IDENT} /ox
        
      
        

          1
          
              OBJECT_VARIABLE = / @@? #{IDENT} /ox
        
      
        

          1
          
              GLOBAL_VARIABLE = / \$ (?: #{IDENT} | [1-9]\d* | 0\w* | [~&+`'=\/,;_.<>!@$?*":\\] | -[a-zA-Z_0-9] ) /ox
        
      
        

          1
          
              PREFIX_VARIABLE = / #{GLOBAL_VARIABLE} | #{OBJECT_VARIABLE} /ox
        
      
        

          1
          
              VARIABLE = / @?@? #{IDENT} | #{GLOBAL_VARIABLE} /ox
        
      
        

          
          
              
        
      
        

          1
          
              QUOTE_TO_TYPE = {
        
      
        

          
          
                '`' => :shell,
        
      
        

          
          
                '/'=> :regexp,
        
      
        

          
          
              }
        
      
        

          1
          
              QUOTE_TO_TYPE.default = :string
        
      
        

          
          
              
        
      
        

          1
          
              REGEXP_MODIFIERS = /[mousenix]*/
        
      
        

          
          
              
        
      
        

          1
          
              DECIMAL = /\d+(?:_\d+)*/
        
      
        

          1
          
              OCTAL = /0_?[0-7]+(?:_[0-7]+)*/
        
      
        

          1
          
              HEXADECIMAL = /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/
        
      
        

          1
          
              BINARY = /0b[01]+(?:_[01]+)*/
        
      
        

          
          
              
        
      
        

          1
          
              EXPONENT = / [eE] [+-]? #{DECIMAL} /ox
        
      
        

          1
          
              FLOAT_SUFFIX = / #{EXPONENT} | \. #{DECIMAL} #{EXPONENT}? /ox
        
      
        

          1
          
              FLOAT_OR_INT = / #{DECIMAL} (?: #{FLOAT_SUFFIX} () )? /ox
        
      
        

          1
          
              NUMERIC = / (?: (?=0) (?: #{OCTAL} | #{HEXADECIMAL} | #{BINARY} ) | #{FLOAT_OR_INT} ) /ox
        
      
        

          
          
              
        
      
        

          1
          
              SYMBOL = /
        
      
        

          
          
                :
        
      
        

          
          
                (?:
        
      
        

          
          
                  #{METHOD_NAME_EX}
        
      
        

          
          
                | #{PREFIX_VARIABLE}
        
      
        

          
          
                | ['"]
        
      
        

          
          
                )
        
      
        

          
          
              /ox
        
      
        

          1
          
              METHOD_NAME_OR_SYMBOL = / #{METHOD_NAME_EX} | #{SYMBOL} /ox
        
      
        

          
          
              
        
      
        

          1
          
              SIMPLE_ESCAPE = /
        
      
        

          
          
                  [abefnrstv]
        
      
        

          
          
                |  [0-7]{1,3}
        
      
        

          
          
                | x[0-9A-Fa-f]{1,2}
        
      
        

          
          
                | .
        
      
        

          
          
              /mx
        
      
        

          
          
              
        
      
        

          1
          
              CONTROL_META_ESCAPE = /
        
      
        

          
          
                (?: M-|C-|c )
        
      
        

          
          
                (?: \\ (?: M-|C-|c ) )*
        
      
        

          
          
                (?: [^\\] | \\ #{SIMPLE_ESCAPE} )?
        
      
        

          
          
              /mox
        
      
        

          
          
              
        
      
        

          1
          
              ESCAPE = /
        
      
        

          
          
                #{CONTROL_META_ESCAPE} | #{SIMPLE_ESCAPE}
        
      
        

          
          
              /mox
        
      
        

          
          
              
        
      
        

          1
          
              CHARACTER = /
        
      
        

          
          
                \?
        
      
        

          
          
                (?:
        
      
        

          
          
                  [^\s\\]
        
      
        

          
          
                | \\ #{ESCAPE}
        
      
        

          
          
                )
        
      
        

          
          
              /mox
        
      
        

          
          
              
        
      
        

          
          
              # NOTE: This is not completely correct, but
        
      
        

          
          
              # nobody needs heredoc delimiters ending with \n.
        
      
        

          1
          
              HEREDOC_OPEN = /
        
      
        

          
          
                << (-)?              # $1 = float
        
      
        

          
          
                (?:
        
      
        

          
          
                  ( [A-Za-z_0-9]+ )  # $2 = delim
        
      
        

          
          
                |
        
      
        

          
          
                  ( ["'`\/] )        # $3 = quote, type
        
      
        

          
          
                  ( [^\n]*? ) \3     # $4 = delim
        
      
        

          
          
                )
        
      
        

          
          
              /mx
        
      
        

          
          
              
        
      
        

          1
          
              RUBYDOC = /
        
      
        

          
          
                =begin (?!\S)
        
      
        

          
          
                .*?
        
      
        

          
          
                (?: \Z | ^=end (?!\S) [^\n]* )
        
      
        

          
          
              /mx
        
      
        

          
          
              
        
      
        

          1
          
              DATA = /
        
      
        

          
          
                __END__$
        
      
        

          
          
                .*?
        
      
        

          
          
                (?: \Z | (?=^\#CODE) )
        
      
        

          
          
              /mx
        
      
        

          
          
              
        
      
        

          1
          
              RUBYDOC_OR_DATA = / #{RUBYDOC} | #{DATA} /xo
        
      
        

          
          
              
        
      
        

          
          
              # Checks for a valid value to follow. This enables
        
      
        

          
          
              # value_expected in method calls without parentheses.
        
      
        

          1
          
              VALUE_FOLLOWS = /
        
      
        

          
          
                (?>[ \t\f\v]+)
        
      
        

          
          
                (?:
        
      
        

          
          
                  [%\/][^\s=]
        
      
        

          
          
                | <<-?\S
        
      
        

          
          
                | [-+] \d
        
      
        

          
          
                | #{CHARACTER}
        
      
        

          
          
                )
        
      
        

          
          
              /ox
        
      
        

          1
          
              KEYWORDS_EXPECTING_VALUE = WordList.new.add(%w[
        
      
        

          
          
                and end in or unless begin
        
      
        

          
          
                defined? ensure redo super until
        
      
        

          
          
                break do next rescue then
        
      
        

          
          
                when case else for retry
        
      
        

          
          
                while elsif if not return
        
      
        

          
          
                yield
        
      
        

          
          
              ])
        
      
        

          
          
              
        
      
        

          1
          
              FANCY_STRING_START = / % ( [iIqQrswWx] | (?![a-zA-Z0-9]) ) ([^a-zA-Z0-9]) /x
        
      
        

          1
          
              FANCY_STRING_KIND = Hash.new(:string).merge({
        
      
        

          
          
                'i' => :symbol,
        
      
        

          
          
                'I' => :symbol,
        
      
        

          
          
                'r' => :regexp,
        
      
        

          
          
                's' => :symbol,
        
      
        

          
          
                'x' => :shell,
        
      
        

          
          
              })
        
      
        

          1
          
              FANCY_STRING_INTERPRETED = Hash.new(true).merge({
        
      
        

          
          
                'i' => false,
        
      
        

          
          
                'q' => false,
        
      
        

          
          
                's' => false,
        
      
        

          
          
                'w' => false,
        
      
        

          
          
              })
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # encoding: utf-8
        
      
        

          1
          
          module CodeRay
        
      
        

          1
          
          module Scanners
        
      
        

          
          
            
        
      
        

          1
          
            class Ruby
        
      
        

          
          
              
        
      
        

          
          
              class StringState < Struct.new :type, :interpreted, :delim, :heredoc,
        
      
        

          1
          
                :opening_paren, :paren_depth, :pattern, :next_state  # :nodoc: all
        
      
        

          
          
                
        
      
        

          1
          
                CLOSING_PAREN = Hash[ *%w[
        
      
        

          
          
                  ( )
        
      
        

          
          
                  [ ]
        
      
        

          
          
                  < >
        
      
        

          
          
                  { }
        
      
        

          4
          
                ] ].each { |k,v| k.freeze; v.freeze }  # debug, if I try to change it with <<
        
      
        

          
          
                
        
      
        

          1
          
                STRING_PATTERN = Hash.new do |h, k|
        
      
        

          1
          
                  delim, interpreted = *k
        
      
        

          1
          
                  delim_pattern = Regexp.escape(delim)
        
      
        

          1
          
                  if closing_paren = CLOSING_PAREN[delim]
        
      
        

          
          
                    delim_pattern << Regexp.escape(closing_paren)
        
      
        

          
          
                  end
        
      
        

          1
          
                  delim_pattern << '\\\\' unless delim == '\\'
        
      
        

          
          
                  
        
      
        

          
          
                  # special_escapes =
        
      
        

          
          
                  #   case interpreted
        
      
        

          
          
                  #   when :regexp_symbols
        
      
        

          
          
                  #     '| [|?*+(){}\[\].^$]'
        
      
        

          
          
                  #   end
        
      
        

          
          
                  
        
      
        

          
          
                  if interpreted && delim != '#'
        
      
        

          1
          
                    / (?= [#{delim_pattern}] | \# [{$@] ) /mx
        
      
        

          
          
                  else
        
      
        

          
          
                    / (?= [#{delim_pattern}] ) /mx
        
      
        

          1
          
                  end.tap do |pattern|
        
      
        

          1
          
                    h[k] = pattern if (delim.respond_to?(:ord) ? delim.ord : delim[0]) < 256
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def initialize kind, interpreted, delim, heredoc = false
        
      
        

          15
          
                  if heredoc
        
      
        

          
          
                    pattern = heredoc_pattern delim, interpreted, heredoc == :indented
        
      
        

          
          
                    delim = nil
        
      
        

          
          
                  else
        
      
        

          15
          
                    pattern = STRING_PATTERN[ [delim, interpreted] ]
        
      
        

          15
          
                    if closing_paren = CLOSING_PAREN[delim]
        
      
        

          
          
                      opening_paren = delim
        
      
        

          
          
                      delim = closing_paren
        
      
        

          
          
                      paren_depth = 1
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          15
          
                  super kind, interpreted, delim, heredoc, opening_paren, paren_depth, pattern, :initial
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          1
          
                def heredoc_pattern delim, interpreted, indented
        
      
        

          
          
                  # delim = delim.dup  # workaround for old Ruby
        
      
        

          
          
                  delim_pattern = Regexp.escape(delim)
        
      
        

          
          
                  delim_pattern = / (?:\A|\n) #{ '(?>[ \t]*)' if indented } #{ Regexp.new delim_pattern } $ /x
        
      
        

          
          
                  if interpreted
        
      
        

          
          
                    / (?= #{delim_pattern}() | \\ | \# [{$@] ) /mx  # $1 set == end of heredoc
        
      
        

          
          
                  else
        
      
        

          
          
                    / (?= #{delim_pattern}() | \\ ) /mx
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          
          
            # The Tokens class represents a list of tokens returned from
        
      
        

          
          
            # a Scanner. It's actually just an Array with a few helper methods.
        
      
        

          
          
            #
        
      
        

          
          
            # A token itself is not a special object, just two elements in an Array:
        
      
        

          
          
            # * the _token_ _text_ (the original source of the token in a String) or
        
      
        

          
          
            #   a _token_ _action_ (begin_group, end_group, begin_line, end_line)
        
      
        

          
          
            # * the _token_ _kind_ (a Symbol representing the type of the token)
        
      
        

          
          
            #
        
      
        

          
          
            # It looks like this:
        
      
        

          
          
            #
        
      
        

          
          
            #   ..., '# It looks like this', :comment, ...
        
      
        

          
          
            #   ..., '3.1415926', :float, ...
        
      
        

          
          
            #   ..., '$^', :error, ...
        
      
        

          
          
            #
        
      
        

          
          
            # Some scanners also yield sub-tokens, represented by special
        
      
        

          
          
            # token actions, for example :begin_group and :end_group.
        
      
        

          
          
            #
        
      
        

          
          
            # The Ruby scanner, for example, splits "a string" into:
        
      
        

          
          
            #
        
      
        

          
          
            #  [
        
      
        

          
          
            #   :begin_group, :string,
        
      
        

          
          
            #   '"',          :delimiter,
        
      
        

          
          
            #   'a string',   :content,
        
      
        

          
          
            #   '"',          :delimiter,
        
      
        

          
          
            #   :end_group,   :string
        
      
        

          
          
            #  ]
        
      
        

          
          
            #
        
      
        

          
          
            # Tokens can be used to save the output of a Scanners in a simple
        
      
        

          
          
            # Ruby object that can be send to an Encoder later:
        
      
        

          
          
            #
        
      
        

          
          
            #   tokens = CodeRay.scan('price = 2.59', :ruby).tokens
        
      
        

          
          
            #   tokens.encode(:html)
        
      
        

          
          
            #   tokens.html
        
      
        

          
          
            #   CodeRay.encoder(:html).encode_tokens(tokens)
        
      
        

          
          
            #
        
      
        

          
          
            # Tokens gives you the power to handle pre-scanned code very easily:
        
      
        

          
          
            # You can serialize it to a JSON string and store it in a database, pass it
        
      
        

          
          
            # around to encode it more than once, send it to other algorithms...
        
      
        

          1
          
            class Tokens < Array
        
      
        

          
          
              
        
      
        

          
          
              # The Scanner instance that created the tokens.
        
      
        

          1
          
              attr_accessor :scanner
        
      
        

          
          
              
        
      
        

          
          
              # Encode the tokens using encoder.
        
      
        

          
          
              #
        
      
        

          
          
              # encoder can be
        
      
        

          
          
              # * a plugin name like :html oder 'statistic'
        
      
        

          
          
              # * an Encoder object
        
      
        

          
          
              #
        
      
        

          
          
              # options are passed to the encoder.
        
      
        

          1
          
              def encode encoder, options = {}
        
      
        

          
          
                encoder = Encoders[encoder].new options if encoder.respond_to? :to_sym
        
      
        

          
          
                encoder.encode_tokens self, options
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Turn tokens into a string by concatenating them.
        
      
        

          1
          
              def to_s
        
      
        

          
          
                encode CodeRay::Encoders::Encoder.new
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Redirects unknown methods to encoder calls.
        
      
        

          
          
              #
        
      
        

          
          
              # For example, if you call +tokens.html+, the HTML encoder
        
      
        

          
          
              # is used to highlight the tokens.
        
      
        

          1
          
              def method_missing meth, options = {}
        
      
        

          
          
                encode meth, options
        
      
        

          
          
              rescue PluginHost::PluginNotFound
        
      
        

          
          
                super
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Split the tokens into parts of the given +sizes+.
        
      
        

          
          
              # 
        
      
        

          
          
              # The result will be an Array of Tokens objects. The parts have
        
      
        

          
          
              # the text size specified by the parameter. In addition, each
        
      
        

          
          
              # part closes all opened tokens. This is useful to insert tokens
        
      
        

          
          
              # betweem them.
        
      
        

          
          
              # 
        
      
        

          
          
              # This method is used by @Scanner#tokenize@ when called with an Array
        
      
        

          
          
              # of source strings. The Diff encoder uses it for inline highlighting.
        
      
        

          1
          
              def split_into_parts *sizes
        
      
        

          
          
                return Array.new(sizes.size) { Tokens.new } if size == 2 && first == ''
        
      
        

          
          
                parts = []
        
      
        

          
          
                opened = []
        
      
        

          
          
                content = nil
        
      
        

          
          
                part = Tokens.new
        
      
        

          
          
                part_size = 0
        
      
        

          
          
                size = sizes.first
        
      
        

          
          
                i = 0
        
      
        

          
          
                for item in self
        
      
        

          
          
                  case content
        
      
        

          
          
                  when nil
        
      
        

          
          
                    content = item
        
      
        

          
          
                  when String
        
      
        

          
          
                    if size && part_size + content.size > size  # token must be cut
        
      
        

          
          
                      if part_size < size  # some part of the token goes into this part
        
      
        

          
          
                        content = content.dup  # content may no be safe to change
        
      
        

          
          
                        part << content.slice!(0, size - part_size) << item
        
      
        

          
          
                      end
        
      
        

          
          
                      # close all open groups and lines...
        
      
        

          
          
                      closing = opened.reverse.flatten.map do |content_or_kind|
        
      
        

          
          
                        case content_or_kind
        
      
        

          
          
                        when :begin_group
        
      
        

          
          
                          :end_group
        
      
        

          
          
                        when :begin_line
        
      
        

          
          
                          :end_line
        
      
        

          
          
                        else
        
      
        

          
          
                          content_or_kind
        
      
        

          
          
                        end
        
      
        

          
          
                      end
        
      
        

          
          
                      part.concat closing
        
      
        

          
          
                      begin
        
      
        

          
          
                        parts << part
        
      
        

          
          
                        part = Tokens.new
        
      
        

          
          
                        size = sizes[i += 1]
        
      
        

          
          
                      end until size.nil? || size > 0
        
      
        

          
          
                      # ...and open them again.
        
      
        

          
          
                      part.concat opened.flatten
        
      
        

          
          
                      part_size = 0
        
      
        

          
          
                      redo unless content.empty?
        
      
        

          
          
                    else
        
      
        

          
          
                      part << content << item
        
      
        

          
          
                      part_size += content.size
        
      
        

          
          
                    end
        
      
        

          
          
                    content = nil
        
      
        

          
          
                  when Symbol
        
      
        

          
          
                    case content
        
      
        

          
          
                    when :begin_group, :begin_line
        
      
        

          
          
                      opened << [content, item]
        
      
        

          
          
                    when :end_group, :end_line
        
      
        

          
          
                      opened.pop
        
      
        

          
          
                    else
        
      
        

          
          
                      raise ArgumentError, 'Unknown token action: %p, kind = %p' % [content, item]
        
      
        

          
          
                    end
        
      
        

          
          
                    part << content << item
        
      
        

          
          
                    content = nil
        
      
        

          
          
                  else
        
      
        

          
          
                    raise ArgumentError, 'Token input junk: %p, kind = %p' % [content, item]
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
                parts << part
        
      
        

          
          
                parts << Tokens.new while parts.size < sizes.size
        
      
        

          
          
                parts
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Return the actual number of tokens.
        
      
        

          1
          
              def count
        
      
        

          
          
                size / 2
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          1
          
              alias text_token push
        
      
        

          15
          
              def begin_group kind; push :begin_group, kind end
        
      
        

          15
          
              def end_group kind; push :end_group, kind end
        
      
        

          1
          
              def begin_line kind; push :begin_line, kind end
        
      
        

          1
          
              def end_line kind; push :end_line, kind end
        
      
        

          1
          
              alias tokens concat
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          
          
            
        
      
        

          
          
            # The result of a scan operation is a TokensProxy, but should act like Tokens.
        
      
        

          
          
            # 
        
      
        

          
          
            # This proxy makes it possible to use the classic CodeRay.scan.encode API
        
      
        

          
          
            # while still providing the benefits of direct streaming.
        
      
        

          1
          
            class TokensProxy
        
      
        

          
          
              
        
      
        

          1
          
              attr_accessor :input, :lang, :options, :block
        
      
        

          
          
              
        
      
        

          
          
              # Create a new TokensProxy with the arguments of CodeRay.scan.
        
      
        

          1
          
              def initialize input, lang, options = {}, block = nil
        
      
        

          94
          
                @input   = input
        
      
        

          94
          
                @lang    = lang
        
      
        

          94
          
                @options = options
        
      
        

          94
          
                @block   = block
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Call CodeRay.encode if +encoder+ is a Symbol;
        
      
        

          
          
              # otherwise, convert the receiver to tokens and call encoder.encode_tokens.
        
      
        

          1
          
              def encode encoder, options = {}
        
      
        

          81
          
                if encoder.respond_to? :to_sym
        
      
        

          81
          
                  CodeRay.encode(input, lang, encoder, options)
        
      
        

          
          
                else
        
      
        

          
          
                  encoder.encode_tokens tokens, options
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Tries to call encode;
        
      
        

          
          
              # delegates to tokens otherwise.
        
      
        

          1
          
              def method_missing method, *args, &blk
        
      
        

          81
          
                encode method.to_sym, *args
        
      
        

          
          
              rescue PluginHost::PluginNotFound
        
      
        

          
          
                tokens.send(method, *args, &blk)
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # The (cached) result of the tokenized input; a Tokens instance.
        
      
        

          1
          
              def tokens
        
      
        

          13
          
                @tokens ||= scanner.tokenize(input)
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # A (cached) scanner instance to use for the scan task.
        
      
        

          1
          
              def scanner
        
      
        

          13
          
                @scanner ||= CodeRay.scanner(lang, options, &block)
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
              # Overwrite Struct#each.
        
      
        

          1
          
              def each *args, &blk
        
      
        

          
          
                tokens.each(*args, &blk)
        
      
        

          
          
                self
        
      
        

          
          
              end
        
      
        

          
          
              
        
      
        

          
          
            end
        
      
        

          
          
            
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module CodeRay
        
      
        

          1
          
            VERSION = '1.1.0'
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # (C) John Mair (banisterfiend) 2011
        
      
        

          
          
          # MIT License
        
      
        

          
          
          
        
      
        

          1
          
          direc = File.dirname(__FILE__)
        
      
        

          
          
          
        
      
        

          1
          
          require "#{direc}/method_source/version"
        
      
        

          1
          
          require "#{direc}/method_source/source_location"
        
      
        

          1
          
          require "#{direc}/method_source/code_helpers"
        
      
        

          
          
          
        
      
        

          1
          
          module MethodSource
        
      
        

          1
          
            extend MethodSource::CodeHelpers
        
      
        

          
          
          
        
      
        

          
          
            # An Exception to mark errors that were raised trying to find the source from
        
      
        

          
          
            # a given source_location.
        
      
        

          
          
            #
        
      
        

          1
          
            class SourceNotFoundError < StandardError; end
        
      
        

          
          
          
        
      
        

          
          
            # Helper method responsible for extracting method body.
        
      
        

          
          
            # Defined here to avoid polluting `Method` class.
        
      
        

          
          
            # @param [Array] source_location The array returned by Method#source_location
        
      
        

          
          
            # @param [String]  method_name
        
      
        

          
          
            # @return [String] The method body
        
      
        

          1
          
            def self.source_helper(source_location, name=nil)
        
      
        

          
          
              raise SourceNotFoundError, "Could not locate source for #{name}!" unless source_location
        
      
        

          
          
              file, line = *source_location
        
      
        

          
          
          
        
      
        

          
          
              expression_at(lines_for(file), line)
        
      
        

          
          
            rescue SyntaxError => e
        
      
        

          
          
              raise SourceNotFoundError, "Could not parse source for #{name}: #{e.message}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Helper method responsible for opening source file and buffering up
        
      
        

          
          
            # the comments for a specified method. Defined here to avoid polluting
        
      
        

          
          
            # `Method` class.
        
      
        

          
          
            # @param [Array] source_location The array returned by Method#source_location
        
      
        

          
          
            # @param [String]  method_name
        
      
        

          
          
            # @return [String] The comments up to the point of the method.
        
      
        

          1
          
            def self.comment_helper(source_location, name=nil)
        
      
        

          
          
              raise SourceNotFoundError, "Could not locate source for #{name}!" unless source_location
        
      
        

          
          
              file, line = *source_location
        
      
        

          
          
          
        
      
        

          
          
              comment_describing(lines_for(file), line)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # Load a memoized copy of the lines in a file.
        
      
        

          
          
            #
        
      
        

          
          
            # @param [String]  file_name
        
      
        

          
          
            # @param [String]  method_name
        
      
        

          
          
            # @return [Array<String>]  the contents of the file
        
      
        

          
          
            # @raise [SourceNotFoundError]
        
      
        

          1
          
            def self.lines_for(file_name, name=nil)
        
      
        

          
          
              @lines_for_file ||= {}
        
      
        

          
          
              @lines_for_file[file_name] ||= File.readlines(file_name)
        
      
        

          
          
            rescue Errno::ENOENT => e
        
      
        

          
          
              raise SourceNotFoundError, "Could not load source for #{name}: #{e.message}"
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # @deprecated — use MethodSource::CodeHelpers#complete_expression?
        
      
        

          1
          
            def self.valid_expression?(str)
        
      
        

          
          
              complete_expression?(str)
        
      
        

          
          
            rescue SyntaxError
        
      
        

          
          
              false
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # @deprecated — use MethodSource::CodeHelpers#expression_at
        
      
        

          1
          
            def self.extract_code(source_location)
        
      
        

          
          
              source_helper(source_location)
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          
          
            # This module is to be included by `Method` and `UnboundMethod` and
        
      
        

          
          
            # provides the `#source` functionality
        
      
        

          1
          
            module MethodExtensions
        
      
        

          
          
          
        
      
        

          
          
              # We use the included hook to patch Method#source on rubinius.
        
      
        

          
          
              # We need to use the included hook as Rubinius defines a `source`
        
      
        

          
          
              # on Method so including a module will have no effect (as it's
        
      
        

          
          
              # higher up the MRO).
        
      
        

          
          
              # @param [Class] klass The class that includes the module.
        
      
        

          1
          
              def self.included(klass)
        
      
        

          3
          
                if klass.method_defined?(:source) && Object.const_defined?(:RUBY_ENGINE) &&
        
      
        

          
          
                    RUBY_ENGINE =~ /rbx/
        
      
        

          
          
          
        
      
        

          
          
                  klass.class_eval do
        
      
        

          
          
                    orig_source = instance_method(:source)
        
      
        

          
          
          
        
      
        

          
          
                    define_method(:source) do
        
      
        

          
          
                      begin
        
      
        

          
          
                        super
        
      
        

          
          
                      rescue
        
      
        

          
          
                        orig_source.bind(self).call
        
      
        

          
          
                      end
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Return the sourcecode for the method as a string
        
      
        

          
          
              # @return [String] The method sourcecode as a string
        
      
        

          
          
              # @raise SourceNotFoundException
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #  Set.instance_method(:clear).source.display
        
      
        

          
          
              #  =>
        
      
        

          
          
              #     def clear
        
      
        

          
          
              #       @hash.clear
        
      
        

          
          
              #       self
        
      
        

          
          
              #     end
        
      
        

          1
          
              def source
        
      
        

          
          
                MethodSource.source_helper(source_location, defined?(name) ? name : inspect)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Return the comments associated with the method as a string.
        
      
        

          
          
              # @return [String] The method's comments as a string
        
      
        

          
          
              # @raise SourceNotFoundException
        
      
        

          
          
              #
        
      
        

          
          
              # @example
        
      
        

          
          
              #  Set.instance_method(:clear).comment.display
        
      
        

          
          
              #  =>
        
      
        

          
          
              #     # Removes all elements and returns self.
        
      
        

          1
          
              def comment
        
      
        

          
          
                MethodSource.comment_helper(source_location, defined?(name) ? name : inspect)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          class Method
        
      
        

          1
          
            include MethodSource::SourceLocation::MethodExtensions
        
      
        

          1
          
            include MethodSource::MethodExtensions
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          class UnboundMethod
        
      
        

          1
          
            include MethodSource::SourceLocation::UnboundMethodExtensions
        
      
        

          1
          
            include MethodSource::MethodExtensions
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          class Proc
        
      
        

          1
          
            include MethodSource::SourceLocation::ProcExtensions
        
      
        

          1
          
            include MethodSource::MethodExtensions
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
    
  

    

      
        

          1
          
          module MethodSource
        
      
        

          
          
          
        
      
        

          1
          
            module CodeHelpers
        
      
        

          
          
              # Retrieve the first expression starting on the given line of the given file.
        
      
        

          
          
              #
        
      
        

          
          
              # This is useful to get module or method source code.
        
      
        

          
          
              #
        
      
        

          
          
              # @param [Array<String>, File, String] file  The file to parse, either as a File or as
        
      
        

          
          
              # @param [Fixnum]  line_number  The line number at which to look.
        
      
        

          
          
              #                             NOTE: The first line in a file is
        
      
        

          
          
              #                           line 1!
        
      
        

          
          
              # @param [Hash] options The optional configuration parameters.
        
      
        

          
          
              # @option options [Boolean] :strict  If set to true, then only completely
        
      
        

          
          
              #   valid expressions are returned. Otherwise heuristics are used to extract
        
      
        

          
          
              #   expressions that may have been valid inside an eval.
        
      
        

          
          
              # @option options [Fixnum] :consume  A number of lines to automatically
        
      
        

          
          
              #   consume (add to the expression buffer) without checking for validity.
        
      
        

          
          
              # @return [String]  The first complete expression
        
      
        

          
          
              # @raise [SyntaxError]  If the first complete expression can't be identified
        
      
        

          1
          
              def expression_at(file, line_number, options={})
        
      
        

          4
          
                options = {
        
      
        

          
          
                  :strict  => false,
        
      
        

          
          
                  :consume => 0
        
      
        

          
          
                }.merge!(options)
        
      
        

          
          
          
        
      
        

          4
          
                lines = file.is_a?(Array) ? file : file.each_line.to_a
        
      
        

          
          
          
        
      
        

          4
          
                relevant_lines = lines[(line_number - 1)..-1] || []
        
      
        

          
          
          
        
      
        

          4
          
                extract_first_expression(relevant_lines, options[:consume])
        
      
        

          
          
              rescue SyntaxError => e
        
      
        

          
          
                raise if options[:strict]
        
      
        

          
          
          
        
      
        

          
          
                begin
        
      
        

          
          
                  extract_first_expression(relevant_lines) do |code|
        
      
        

          
          
                    code.gsub(/\#\{.*?\}/, "temp")
        
      
        

          
          
                  end
        
      
        

          
          
                rescue SyntaxError
        
      
        

          
          
                  raise e
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Retrieve the comment describing the expression on the given line of the given file.
        
      
        

          
          
              #
        
      
        

          
          
              # This is useful to get module or method documentation.
        
      
        

          
          
              #
        
      
        

          
          
              # @param [Array<String>, File, String] file  The file to parse, either as a File or as
        
      
        

          
          
              #                                            a String or an Array of lines.
        
      
        

          
          
              # @param [Fixnum]  line_number  The line number at which to look.
        
      
        

          
          
              #                             NOTE: The first line in a file is line 1!
        
      
        

          
          
              # @return [String]  The comment
        
      
        

          1
          
              def comment_describing(file, line_number)
        
      
        

          
          
                lines = file.is_a?(Array) ? file : file.each_line.to_a
        
      
        

          
          
          
        
      
        

          
          
                extract_last_comment(lines[0..(line_number - 2)])
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Determine if a string of code is a complete Ruby expression.
        
      
        

          
          
              # @param [String] code The code to validate.
        
      
        

          
          
              # @return [Boolean] Whether or not the code is a complete Ruby expression.
        
      
        

          
          
              # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness.
        
      
        

          
          
              # @example
        
      
        

          
          
              #   complete_expression?("class Hello") #=> false
        
      
        

          
          
              #   complete_expression?("class Hello; end") #=> true
        
      
        

          
          
              #   complete_expression?("class 123") #=> SyntaxError: unexpected tINTEGER
        
      
        

          1
          
              def complete_expression?(str)
        
      
        

          63
          
                old_verbose = $VERBOSE
        
      
        

          63
          
                $VERBOSE = nil
        
      
        

          
          
          
        
      
        

          63
          
                catch(:valid) do
        
      
        

          63
          
                  eval("BEGIN{throw :valid}\n#{str}")
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                # Assert that a line which ends with a , or \ is incomplete.
        
      
        

          14
          
                str !~ /[,\\]\s*\z/
        
      
        

          
          
              rescue IncompleteExpression
        
      
        

          49
          
                false
        
      
        

          
          
              ensure
        
      
        

          63
          
                $VERBOSE = old_verbose
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              private
        
      
        

          
          
          
        
      
        

          
          
              # Get the first expression from the input.
        
      
        

          
          
              #
        
      
        

          
          
              # @param [Array<String>]  lines
        
      
        

          
          
              # @param [Fixnum] consume A number of lines to automatically
        
      
        

          
          
              #   consume (add to the expression buffer) without checking for validity.
        
      
        

          
          
              # @yield a clean-up function to run before checking for complete_expression
        
      
        

          
          
              # @return [String]  a valid ruby expression
        
      
        

          
          
              # @raise [SyntaxError]
        
      
        

          1
          
              def extract_first_expression(lines, consume=0, &block)
        
      
        

          4
          
                code = consume.zero? ? "" : lines.slice!(0..(consume - 1)).join
        
      
        

          
          
          
        
      
        

          4
          
                lines.each do |v|
        
      
        

          39
          
                  code << v
        
      
        

          39
          
                  return code if complete_expression?(block ? block.call(code) : code)
        
      
        

          
          
                end
        
      
        

          
          
                raise SyntaxError, "unexpected $end"
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # Get the last comment from the input.
        
      
        

          
          
              #
        
      
        

          
          
              # @param [Array<String>]  lines
        
      
        

          
          
              # @return [String]
        
      
        

          1
          
              def extract_last_comment(lines)
        
      
        

          
          
                buffer = ""
        
      
        

          
          
          
        
      
        

          
          
                lines.each do |line|
        
      
        

          
          
                  # Add any line that is a valid ruby comment,
        
      
        

          
          
                  # but clear as soon as we hit a non comment line.
        
      
        

          
          
                  if (line =~ /^\s*#/) || (line =~ /^\s*$/)
        
      
        

          
          
                    buffer << line.lstrip
        
      
        

          
          
                  else
        
      
        

          
          
                    buffer.replace("")
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          
          
                buffer
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          
          
              # An exception matcher that matches only subsets of SyntaxErrors that can be
        
      
        

          
          
              # fixed by adding more input to the buffer.
        
      
        

          1
          
              module IncompleteExpression
        
      
        

          1
          
                GENERIC_REGEXPS = [
        
      
        

          
          
                  /unexpected (\$end|end-of-file|end-of-input|END_OF_FILE)/, # mri, jruby, ruby-2.0, ironruby
        
      
        

          
          
                  /embedded document meets end of file/, # =begin
        
      
        

          
          
                  /unterminated (quoted string|string|regexp) meets end of file/, # "quoted string" is ironruby
        
      
        

          
          
                  /can't find string ".*" anywhere before EOF/, # rbx and jruby
        
      
        

          
          
                  /missing 'end' for/, /expecting kWHEN/ # rbx
        
      
        

          
          
                ]
        
      
        

          
          
          
        
      
        

          1
          
                RBX_ONLY_REGEXPS = [
        
      
        

          
          
                  /expecting '[})\]]'(?:$|:)/, /expecting keyword_end/
        
      
        

          
          
                ]
        
      
        

          
          
          
        
      
        

          1
          
                def self.===(ex)
        
      
        

          49
          
                  return false unless SyntaxError === ex
        
      
        

          49
          
                  case ex.message
        
      
        

          
          
                  when *GENERIC_REGEXPS
        
      
        

          49
          
                    true
        
      
        

          
          
                  when *RBX_ONLY_REGEXPS
        
      
        

          
          
                    rbx?
        
      
        

          
          
                  else
        
      
        

          
          
                    false
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
          
        
      
        

          1
          
                def self.rbx?
        
      
        

          
          
                  RbConfig::CONFIG['ruby_install_name'] == 'rbx'
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          module MethodSource
        
      
        

          1
          
            module ReeSourceLocation
        
      
        

          
          
              # Ruby enterprise edition provides all the information that's
        
      
        

          
          
              # needed, in a slightly different way.
        
      
        

          1
          
              def source_location
        
      
        

          
          
                [__file__, __line__] rescue nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            module SourceLocation
        
      
        

          1
          
              module MethodExtensions
        
      
        

          1
          
                if Proc.method_defined? :__file__
        
      
        

          
          
                  include ReeSourceLocation
        
      
        

          
          
          
        
      
        

          
          
                elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
        
      
        

          
          
                  require 'java'
        
      
        

          
          
          
        
      
        

          
          
                  # JRuby version source_location hack
        
      
        

          
          
                  # @return [Array] A two element array containing the source location of the method
        
      
        

          
          
                  def source_location
        
      
        

          
          
                    to_java.source_location(Thread.current.to_java.getContext())
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          1
          
                  def trace_func(event, file, line, id, binding, classname)
        
      
        

          
          
                    return unless event == 'call'
        
      
        

          
          
                    set_trace_func nil
        
      
        

          
          
          
        
      
        

          
          
                    @file, @line = file, line
        
      
        

          
          
                    raise :found
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          1
          
                  private :trace_func
        
      
        

          
          
          
        
      
        

          
          
                  # Return the source location of a method for Ruby 1.8.
        
      
        

          
          
                  # @return [Array] A two element array. First element is the
        
      
        

          
          
                  #   file, second element is the line in the file where the
        
      
        

          
          
                  #   method definition is found.
        
      
        

          1
          
                  def source_location
        
      
        

          
          
                    if @file.nil?
        
      
        

          
          
                      args =[*(1..(arity<-1 ? -arity-1 : arity ))]
        
      
        

          
          
          
        
      
        

          
          
                      set_trace_func method(:trace_func).to_proc
        
      
        

          
          
                      call(*args) rescue nil
        
      
        

          
          
                      set_trace_func nil
        
      
        

          
          
                      @file = File.expand_path(@file) if @file && File.exist?(File.expand_path(@file))
        
      
        

          
          
                    end
        
      
        

          
          
                    [@file, @line] if @file
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              module ProcExtensions
        
      
        

          1
          
                if Proc.method_defined? :__file__
        
      
        

          
          
                  include ReeSourceLocation
        
      
        

          
          
          
        
      
        

          
          
                elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
        
      
        

          
          
          
        
      
        

          
          
                  # Return the source location for a Proc (Rubinius only)
        
      
        

          
          
                  # @return [Array] A two element array. First element is the
        
      
        

          
          
                  #   file, second element is the line in the file where the
        
      
        

          
          
                  #   proc definition is found.
        
      
        

          
          
                  def source_location
        
      
        

          
          
                    [block.file.to_s, block.line]
        
      
        

          
          
                  end
        
      
        

          
          
                else
        
      
        

          
          
          
        
      
        

          
          
                  # Return the source location for a Proc (in implementations
        
      
        

          
          
                  # without Proc#source_location)
        
      
        

          
          
                  # @return [Array] A two element array. First element is the
        
      
        

          
          
                  #   file, second element is the line in the file where the
        
      
        

          
          
                  #   proc definition is found.
        
      
        

          1
          
                  def source_location
        
      
        

          
          
                    self.to_s =~ /@(.*):(\d+)/
        
      
        

          
          
                    [$1, $2.to_i]
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              module UnboundMethodExtensions
        
      
        

          1
          
                if Proc.method_defined? :__file__
        
      
        

          
          
                  include ReeSourceLocation
        
      
        

          
          
          
        
      
        

          
          
                elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
        
      
        

          
          
                  require 'java'
        
      
        

          
          
          
        
      
        

          
          
                  # JRuby version source_location hack
        
      
        

          
          
                  # @return [Array] A two element array containing the source location of the method
        
      
        

          
          
                  def source_location
        
      
        

          
          
                    to_java.source_location(Thread.current.to_java.getContext())
        
      
        

          
          
                  end
        
      
        

          
          
          
        
      
        

          
          
                else
        
      
        

          
          
          
        
      
        

          
          
          
        
      
        

          
          
                  # Return the source location of an instance method for Ruby 1.8.
        
      
        

          
          
                  # @return [Array] A two element array. First element is the
        
      
        

          
          
                  #   file, second element is the line in the file where the
        
      
        

          
          
                  #   method definition is found.
        
      
        

          1
          
                  def source_location
        
      
        

          
          
                    klass = case owner
        
      
        

          
          
                            when Class
        
      
        

          
          
                              owner
        
      
        

          
          
                            when Module
        
      
        

          
          
                              method_owner = owner
        
      
        

          
          
                              Class.new { include(method_owner) }
        
      
        

          
          
                            end
        
      
        

          
          
          
        
      
        

          
          
                    # deal with immediate values
        
      
        

          
          
                    case
        
      
        

          
          
                    when klass == Symbol
        
      
        

          
          
                      return :a.method(name).source_location
        
      
        

          
          
                    when klass == Fixnum
        
      
        

          
          
                      return 0.method(name).source_location
        
      
        

          
          
                    when klass == TrueClass
        
      
        

          
          
                      return true.method(name).source_location
        
      
        

          
          
                    when klass == FalseClass
        
      
        

          
          
                      return false.method(name).source_location
        
      
        

          
          
                    when klass == NilClass
        
      
        

          
          
                      return nil.method(name).source_location
        
      
        

          
          
                    end
        
      
        

          
          
          
        
      
        

          
          
                    begin
        
      
        

          
          
                      Object.instance_method(:method).bind(klass.allocate).call(name).source_location
        
      
        

          
          
                    rescue TypeError
        
      
        

          
          
          
        
      
        

          
          
                      # Assume we are dealing with a Singleton Class:
        
      
        

          
          
                      # 1. Get the instance object
        
      
        

          
          
                      # 2. Forward the source_location lookup to the instance
        
      
        

          
          
                      instance ||= ObjectSpace.each_object(owner).first
        
      
        

          
          
                      Object.instance_method(:method).bind(instance).call(name).source_location
        
      
        

          
          
                    end
        
      
        

          
          
                  end
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end